diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 0000000..f487395 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,22 @@ +FROM --platform=linux/amd64 pulumi/pulumi:3.181.0 + + +# create a directory for pulumictl and download the binary to it and set to PATH +RUN mkdir -p /root/pulumictl && cd /root/pulumictl/ +RUN wget https://github.com/pulumi/pulumictl/releases/download/v0.0.42/pulumictl-v0.0.42-linux-amd64.tar.gz -O /root/pulumictl/pulumictl-v0.0.42-linux-amd64.tar.gz +RUN tar -xvf /root/pulumictl/pulumictl-v0.0.42-linux-amd64.tar.gz -C /root/pulumictl/ +ENV PATH="//root/pulumictl/:${PATH}" + +RUN apt update +RUN apt install sudo -y + +RUN type -p curl >/dev/null || (sudo apt update && sudo apt install curl -y) +RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg +RUN sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg +RUN echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null +RUN sudo apt update +RUN sudo apt install gh -y +RUN sudo apt install vim -y + +RUN go install github.com/pulumi/upgrade-provider@main +RUN pip install setuptools diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 0000000..728066d --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,12 @@ +{ + "build": { + "dockerfile": "Dockerfile" + }, + "customizations": { + "vscode": { + "extensions": [ + "golang.go" + ] + } + } +} diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index 7ec96a1..65bb0f7 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -1 +1 @@ -* @stackitcloud/developer-tools \ No newline at end of file +* @stackitcloud/developer-tools diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md index 23d6345..182a662 100644 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -1,6 +1,6 @@ --- name: Bug report -about: Report a bug in the STACKIT pulumi provider +about: Report a bug in the STACKIT Pulumi Provider title: '' labels: bug assignees: '' @@ -26,16 +26,17 @@ assignees: '' ## Actual behavior -*Please describe the current behavior of the STACKIT pulumi provider. Don't forget to add detailed information like error messages.* +*Please describe the current behavior of the STACKIT Pulumi Provider. Don't forget to add detailed information like error messages.* ## Expected behavior -*Please describe the behavior which you would expect from the STACKIT pulumi provider in that case.* +*Please describe the behavior which you would expect from the STACKIT Pulumi Provider in that case.* ## Environment - OS: - - pulumi version (see `pulumi --version`): `vX.X.X` - - Version of the STACKIT pulumi provider: `vX.X.X` + - pulumi version (see `pulumi version`): `vX.X.X` + - pulumictl version (see `pulumictl version`) `X.X.X` + - Version of the STACKIT Pulumi Provider: `vX.X.X` **Additional information** diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md index 379d8d1..bcff1f6 100644 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -1,6 +1,6 @@ --- name: Feature request -about: Suggest an idea for the STACKIT pulumi provider +about: Suggest an idea for the STACKIT Pulumi Provider title: '' labels: enhancement assignees: '' diff --git a/.github/actions/gotools/action.yaml b/.github/actions/gotools/action.yaml new file mode 100644 index 0000000..278c712 --- /dev/null +++ b/.github/actions/gotools/action.yaml @@ -0,0 +1,16 @@ +name: Install Go Tools +description: "Install Go Tools for pipeline" +inputs: + go-version: + description: "Go version to install" + required: true +runs: + using: "composite" + steps: + - name: Install Go ${{ inputs.go-version }} + uses: actions/setup-go@v5 + with: + go-version: ${{ inputs.go-version }} + - name: Install project tools and dependencies + shell: bash + run: make project-tools \ No newline at end of file diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..76ec54f --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,44 @@ +version: 2 +updates: + - package-ecosystem: "gomod" + directory: "/provider" + schedule: + interval: "weekly" + time: "08:00" + day: "sunday" + labels: + - "dependencies" + commit-message: + prefix: "chore" + include: "scope" + - package-ecosystem: "gomod" + directory: "/sdk" + schedule: + interval: "weekly" + day: "sunday" + time: "08:00" + labels: + - "dependencies" + commit-message: + prefix: "chore" + include: "scope" + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "weekly" + day: "sunday" + time: "08:00" + labels: + - "dependencies" + commit-message: + prefix: "chore" + include: "scope" + - package-ecosystem: "docker" + directory: "/.devcontainer" + schedule: + interval: "daily" + labels: + - "dependencies" + commit-message: + prefix: "chore" + include: "scope" \ No newline at end of file diff --git a/.github/workflows/check-upgrade-provider.yaml b/.github/workflows/check-upgrade-provider.yaml new file mode 100644 index 0000000..323b8a3 --- /dev/null +++ b/.github/workflows/check-upgrade-provider.yaml @@ -0,0 +1,21 @@ +env: + GH_TOKEN: ${{ secrets.GH_TOKEN }} +jobs: + upgrade_provider: + name: upgrade-provider + runs-on: ubuntu-latest + steps: + - name: Call upgrade provider action + uses: pulumi/pulumi-upgrade-provider-action@3c670a7cb92732324c8ccc17f7f9ef9dfca126d0 # v0.0.17 + with: + kind: check-upstream-version + +permissions: + contents: write + +name: Check upstream upgrade +on: + workflow_dispatch: {} #so we can run this manually if necessary. + schedule: + # 3 AM UTC ~ 8 PM PDT / 7 PM PST daily. Time chosen to run during off hours. + - cron: 0 3 * * * diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 0000000..1ba0c47 --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,59 @@ +name: CI Workflow + +on: + pull_request: + workflow_dispatch: + push: + branches: + - main + +permissions: + contents: write + id-token: write + +env: + GO_VERSION: "1.24" + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + +jobs: + main: + name: CI + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Unshallow clone for tags + run: git fetch --prune --unshallow --tags + + - name: Install pulumictl + uses: jaxxstorm/action-install-gh-release@6096f2a2bbfee498ced520b6922ac2c06e990ed2 # tag=v2.1.0 + with: + repo: pulumi/pulumictl + + - name: Install pulumi + uses: pulumi/actions@v4 + + - name: Install Go Tools + uses: ./.github/actions/gotools + with: + go-version: ${{ env.GO_VERSION }} + + - name: Build sdks + run: make build + + - name: Lint + run: make lint_provider + + config: + name: Check GoReleaser config + if: github.event_name == 'pull_request' + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Check GoReleaser + uses: goreleaser/goreleaser-action@v6 + with: + args: check \ No newline at end of file diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 0000000..2c6d36b --- /dev/null +++ b/.github/workflows/release.yaml @@ -0,0 +1,144 @@ +name: release +on: + push: + tags: + - v*.*.* + workflow_dispatch: + +permissions: + contents: write + id-token: write + +env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + NPM_TOKEN: ${{ secrets.NPM_TOKEN }} + NUGET_PUBLISH_KEY: ${{ secrets.NUGET_PUBLISH_KEY }} + NUGET_FEED_URL: https://api.nuget.org/v3/index.json + PROVIDER: stackit + PULUMI_GO_DEP_ROOT: ${{ github.workspace }}/.. + PULUMI_LOCAL_NUGET: ${{ github.workspace }}/nuget + PYPI_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + PYPI_USERNAME: "__token__" + PUBLISH_PYPI: true + PUBLISH_NPM: true + PUBLISH_NUGET: true +jobs: + publish_binary: + name: publish + runs-on: ubuntu-latest + steps: + - name: Checkout Repo + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2 + - name: Unshallow clone for tags + run: git fetch --prune --unshallow --tags + - name: Install pulumictl + uses: jaxxstorm/action-install-gh-release@6096f2a2bbfee498ced520b6922ac2c06e990ed2 # tag=v2.1.0 + with: + repo: pulumi/pulumictl + - name: Install Go Tools + uses: ./.github/actions/gotools + with: + go-version: ${{ matrix.goversion }} + - name: Set PreRelease Version + run: echo "GORELEASER_CURRENT_TAG=v$(pulumictl get version --language generic)" >> $GITHUB_ENV + - uses: sigstore/cosign-installer@398d4b0eeef1380460a10c8013a76f728fb906ac # v3.9.1 + - uses: anchore/sbom-action/download-syft@cee1b8e05ae5b2593a75e197229729eabaa9f8ec # v0.20.2 + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@9c156ee8a17a598857849441385a2041ef570552 # tag=v6.3.0 + with: + args: -p 3 release --clean + version: '~> v2' + - name: Create tag + uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # tag=v7.0.1 + with: + script: | + github.rest.git.createRef({ + owner: context.repo.owner, + repo: context.repo.repo, + ref: 'refs/tags/sdk/${{ github.ref_name }}', + sha: context.sha + }) + strategy: + fail-fast: true + matrix: + goversion: + - 1.24.x + publish_sdk: + name: Publish SDKs + runs-on: ubuntu-latest + needs: publish_binary + steps: + - name: Checkout Repo + uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # tag=v4.2.2 + - name: Unshallow clone for tags + run: git fetch --prune --unshallow --tags + - name: Install pulumictl + uses: jaxxstorm/action-install-gh-release@6096f2a2bbfee498ced520b6922ac2c06e990ed2 # tag=v2.1.0 + with: + repo: pulumi/pulumictl + - name: Install Pulumi CLI + uses: pulumi/action-install-pulumi-cli@b374ceb6168550de27c6eba92e01c1a774040e11 # tag=v2.0.0 + - name: Install Go Tools + uses: ./.github/actions/gotools + with: + go-version: ${{ matrix.goversion }} + - name: Setup Node + uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # tag=v4.4.0 + with: + node-version: ${{matrix.nodeversion}} + registry-url: ${{env.NPM_REGISTRY_URL}} + - name: Setup DotNet + uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # tag=v2.1.0 + with: + dotnet-version: ${{matrix.dotnetverson}} + - name: Setup Python + uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # tag=v5.6.0 + with: + python-version: ${{matrix.pythonversion}} + - name: Build SDK + run: make build_${{ matrix.language }} + - name: Check worktree clean + run: | + git update-index -q --refresh + if ! git diff-files --quiet; then + >&2 echo "error: working tree is not clean, aborting!" + git status + git diff + exit 1 + fi + - if: ${{ matrix.language == 'python' && env.PUBLISH_PYPI == 'true' }} + name: Publish package to PyPI + uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # tag=v1.12.4 + with: + user: ${{ env.PYPI_USERNAME }} + password: ${{ env.PYPI_PASSWORD }} + packages_dir: ${{github.workspace}}/sdk/python/bin/dist + - if: ${{ matrix.language == 'nodejs' && env.PUBLISH_NPM == 'true' }} + uses: JS-DevTools/npm-publish@19c28f1ef146469e409470805ea4279d47c3d35c # tag=v3.1.1 + with: + access: "public" + token: ${{ env.NPM_TOKEN }} + package: ${{github.workspace}}/sdk/nodejs/bin/package.json + provenance: true + - if: ${{ matrix.language == 'dotnet' && env.PUBLISH_NUGET == 'true' }} + name: publish nuget package + run: | + dotnet nuget push ${{github.workspace}}/sdk/dotnet/bin/Debug/*.nupkg -s ${{ env.NUGET_FEED_URL }} -k ${{ env.NUGET_PUBLISH_KEY }} + echo "done publishing packages" + strategy: + fail-fast: true + matrix: + dotnetversion: + - 3.1.301 + goversion: + - 1.24.x + language: + - nodejs + - python + - dotnet + - go + nodeversion: + - 20.x + pythonversion: + - "3.9" diff --git a/.github/workflows/upgrade-provider.yaml b/.github/workflows/upgrade-provider.yaml new file mode 100644 index 0000000..98cc9f6 --- /dev/null +++ b/.github/workflows/upgrade-provider.yaml @@ -0,0 +1,22 @@ +env: + GH_TOKEN: ${{ secrets.GH_TOKEN }} +jobs: + upgrade_provider: + if: ${{ (contains(github.event.issue.title, 'Upgrade terraform-provider-')) || github.event_name == 'workflow_dispatch' }} + name: upgrade-provider + runs-on: ubuntu-latest + steps: + - name: Call upgrade provider action + uses: pulumi/pulumi-upgrade-provider-action@3c670a7cb92732324c8ccc17f7f9ef9dfca126d0 # v0.0.17 + with: + kind: all +name: Upgrade provider + +permissions: + contents: write + +on: + issues: + types: + - opened + workflow_dispatch: {} diff --git a/.gitignore b/.gitignore index e69de29..370f91b 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1,24 @@ +.idea +.code +pulumi-stackit.sln +**/vendor/ +.pulumi +**/bin/ +**/obj/ +Pulumi.*.yaml +**/node_modules/ +.DS_Store + +**/command-output/ + +.idea/ +*.iml + +yarn.lock +**/pulumiManifest.go + +ci-scripts +provider/**/schema-embed.json +**/version.txt +**/nuget +**/dist diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 0000000..3487f74 --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,95 @@ +# This file contains all available configuration options +# with their default values. + +# options for analysis running +run: + # default concurrency is a available CPU number + concurrency: 4 + + # timeout for analysis, e.g. 30s, 5m, default is 1m + timeout: 5m +linters-settings: + goimports: + # put imports beginning with prefix after 3rd-party packages; + # it's a comma-separated list of prefixes + local-prefixes: github.com/freiheit-com/nmww + depguard: + rules: + main: + list-mode: lax # Everything is allowed unless it is denied + deny: + - pkg: "github.com/stretchr/testify" + desc: Do not use a testing framework + misspell: + # Correct spellings using locale preferences for US or UK. + # Default is to use a neutral variety of English. + # Setting locale to US will correct the British spelling of 'colour' to 'color'. + locale: US + golint: + min-confidence: 0.8 + gosec: + excludes: + # Suppressions: (see https://github.com/securego/gosec#available-rules for details) + - G104 # "Audit errors not checked" -> which we don't need and is a badly implemented version of errcheck + - G102 # "Bind to all interfaces" -> since this is normal in k8s + - G304 # "File path provided as taint input" -> too many false positives + - G307 # "Deferring unsafe method "Close" on type "io.ReadCloser" -> false positive when calling defer resp.Body.Close() + nakedret: + max-func-lines: 0 + revive: + ignore-generated-header: true + severity: error + # https://github.com/mgechev/revive + rules: + - name: errorf + - name: context-as-argument + - name: error-return + - name: increment-decrement + - name: indent-error-flow + - name: superfluous-else + - name: unused-parameter + - name: unreachable-code + - name: atomic + - name: empty-lines + - name: early-return + gocritic: + enabled-tags: + - performance + - style + - experimental + disabled-checks: + - wrapperFunc + - typeDefFirst + - ifElseChain + - dupImport # https://github.com/go-critic/go-critic/issues/845 +linters: + enable: + # https://golangci-lint.run/usage/linters/ + # default linters + - gosimple + - govet + - ineffassign + - staticcheck + - typecheck + - unused + # additional linters + - errorlint + - gochecknoinits + - gocritic + - gofmt + - goimports + - gosec + - misspell + - nakedret + - revive + - depguard + - bodyclose + - sqlclosecheck + - wastedassign + - forcetypeassert + - errcheck + disable: + - noctx # false positive: finds errors with http.NewRequest that dont make sense + - unparam # false positives +issues: + exclude-use-default: false diff --git a/.goreleaser.yaml b/.goreleaser.yaml new file mode 100644 index 0000000..b4e6ee5 --- /dev/null +++ b/.goreleaser.yaml @@ -0,0 +1,74 @@ +version: 2 +archives: + - id: archive + name_template: '{{ .Binary }}-{{ .Tag }}-{{ .Os }}-{{ .Arch }}' + +before: + hooks: + - make tfgen +builds: + - binary: pulumi-resource-stackit + dir: provider + env: + - CGO_ENABLED=0 + goarch: + - amd64 + - arm64 + goos: + - darwin + - windows + - linux + ldflags: + # The line below MUST align with the module in current provider/go.mod + - -X github.com/stackitcloud/pulumi-stackit/provider/pkg/version.Version={{.Tag }} + main: ./cmd/pulumi-resource-stackit/ + +signs: + - cmd: cosign + env: + - COSIGN_EXPERIMENTAL=1 + certificate: '${artifact}.pem' + args: + - sign-blob + - '-y' + - '--output-certificate=${certificate}' + - '--bundle=${signature}' + - '${artifact}' + artifacts: all + output: true + +sboms: + - artifacts: archive + - id: source + artifacts: source + +source: + enabled: true + +changelog: + sort: asc + use: github + filters: + exclude: + - '^test:' + - '^chore' + - Merge pull request + - Merge remote-tracking branch + - Merge branch + - go mod tidy + groups: + - title: 'New Features' + regexp: "^.*feat[(\\w)]*:+.*$" + order: 0 + - title: 'Bug fixes' + regexp: "^.*fix[(\\w)]*:+.*$" + order: 10 + - title: Other work + order: 999 + +release: + disable: false + prerelease: auto + +snapshot: + version_template: '{{ .Tag }}-SNAPSHOT' diff --git a/.pulumi-java-gen.version b/.pulumi-java-gen.version new file mode 100644 index 0000000..f0df1f7 --- /dev/null +++ b/.pulumi-java-gen.version @@ -0,0 +1 @@ +1.13.2 \ No newline at end of file diff --git a/.upgrade-config.yml b/.upgrade-config.yml new file mode 100644 index 0000000..33d23c1 --- /dev/null +++ b/.upgrade-config.yml @@ -0,0 +1,2 @@ +upstream-provider-name: terraform-provider-stackit +allow-missing-docs: true diff --git a/CONTRIBUTION.md b/CONTRIBUTION.md new file mode 100644 index 0000000..5a5d1dd --- /dev/null +++ b/CONTRIBUTION.md @@ -0,0 +1,51 @@ +# Contribute to the STACKIT Pulumi Provider + +Your contribution is welcome! Thank you for your interest in contributing to the STACKIT Pulumi Provider. We greatly value your feedback, feature requests, additions to the code, bug reports or documentation extensions. + +## Table of contents + +- [Developer Guide](#developer-guide) +- [Useful Make commands](#useful-make-commands) +- [Code Contributions](#code-contributions) +- [Bug Reports](#bug-reports) + + +## Developer Guide + +Prerequisites: + +- [`Pulumi`](https://www.pulumi.com/docs/iac/download-install/) +- [`pulumictl`](https://github.com/pulumi/pulumictl) +- [`Go`](https://go.dev/doc/install) 1.23+ + +### Useful Make commands + +These commands can be executed from the project root: + +- `make build`: command to compile and install everything which is needed +- `make tfgen`: installs the provider plugins +- `make generate_sdks`: generates the sdks for all languages +- `make lint_provider`: lint the provider code +- `make fmt`: run code formatter + +## Code Contributions + +To make your contribution, follow these steps: + +1. Check open or recently closed [Pull Requests](https://github.com/stackitcloud/pulumi-stackit/pulls) and [Issues](https://github.com/stackitcloud/pulumi-stackit/issues) to make sure the contribution you are making has not been already tackled by someone else. +2. Fork the repo. +3. Make your changes in a branch that is up-to-date with the original repo's `main` branch. +4. Commit your changes including a descriptive message +5. Create a pull request with your changes. +6. The pull request will be reviewed by the repo maintainers. If you need to make further changes, make additional commits to keep commit history. When the PR is merged, commits will be squashed. + +## Bug Reports + +If you would like to report a bug, please open a [GitHub issue](https://github.com/stackitcloud/pulumi-stackit/issues/new). + +To ensure we can provide the best support to your issue, follow these guidelines: + +1. Go through the existing issues to check if your issue has already been reported. +2. Make sure you are using the latest version of the STACKIT Pulumi Provider, we will not provide bug fixes for older versions. Also, latest versions may have the fix for your bug. +3. Please provide as much information as you can about your environment, e.g. your versions used, your version of the STACKIT Pulumi Provider, which operating system you are using and the corresponding version. +4. Include in your issue the steps to reproduce it, along with code snippets and/or information about your specific use case. This will make the support process much easier and efficient. \ No newline at end of file diff --git a/COPYRIGHT b/COPYRIGHT new file mode 100644 index 0000000..7f75e1e --- /dev/null +++ b/COPYRIGHT @@ -0,0 +1,11 @@ +Except as otherwise noted below and/or in individual files, this +project is licensed under the Apache License, Version 2.0 (see +LICENSE or ). + +This project is a larger work that combines with software written +by third parties, licensed under their own terms. + +Notably, this larger work combines with the Terraform AWS Provider, +which is licensed under the Mozilla Public License 2.0 (see + or the project itself at +). diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8da3a57 --- /dev/null +++ b/Makefile @@ -0,0 +1,153 @@ +PROJECT_NAME := stackit Package + +SHELL := /bin/bash +PACK := stackit +ORG := stackitcloud +PROJECT := github.com/${ORG}/pulumi-${PACK} +NODE_MODULE_NAME := @pulumi/${PACK} +TF_NAME := ${PACK} +PROVIDER_PATH := provider +VERSION_PATH := ${PROVIDER_PATH}/pkg/version.Version +ROOT_DIR ?= $(shell git rev-parse --show-toplevel) +SCRIPTS_BASE ?= $(ROOT_DIR)/scripts + +JAVA_GEN := pulumi-java-gen +JAVA_GEN_VERSION := v0.8.0 +TFGEN := pulumi-tfgen-${PACK} +PROVIDER := pulumi-resource-${PACK} +VERSION := $(shell pulumictl get version) + +TESTPARALLELISM := 4 + +WORKING_DIR := $(shell pwd) + +OS := $(shell uname) +EMPTY_TO_AVOID_SED := "" + +ensure:: + cd provider && go mod tidy + cd sdk && go mod tidy + cd examples && go mod tidy + +prepare:: + @if test -z "${NAME}"; then echo "NAME not set"; exit 1; fi + @if test -z "${REPOSITORY}"; then echo "REPOSITORY not set"; exit 1; fi + @if test ! -d "provider/cmd/pulumi-tfgen-x${EMPTY_TO_AVOID_SED}yz"; then "Project already prepared"; exit 1; fi + + mv "provider/cmd/pulumi-tfgen-x${EMPTY_TO_AVOID_SED}yz" provider/cmd/pulumi-tfgen-${NAME} + mv "provider/cmd/pulumi-resource-x${EMPTY_TO_AVOID_SED}yz" provider/cmd/pulumi-resource-${NAME} + + if [[ "${OS}" != "Darwin" ]]; then \ + sed -i 's,github.com/pulumi/pulumi-xyz,${REPOSITORY},g' provider/go.mod; \ + find ./ ! -path './.git/*' -type f -exec sed -i 's/[x]yz/${NAME}/g' {} \; &> /dev/null; \ + fi + + # In MacOS the -i parameter needs an empty string to execute in place. + if [[ "${OS}" == "Darwin" ]]; then \ + sed -i '' 's,github.com/pulumi/pulumi-xyz,${REPOSITORY},g' provider/go.mod; \ + find ./ ! -path './.git/*' -type f -exec sed -i '' 's/[x]yz/${NAME}/g' {} \; &> /dev/null; \ + fi + +.PHONY: development provider build_sdks build_nodejs build_dotnet build_go build_python cleanup + +development:: install_plugins provider lint_provider build_sdks install_sdks cleanup # Build the provider & SDKs for a development environment + +# Required for the codegen action that runs in pulumi/pulumi and pulumi/pulumi-terraform-bridge +build:: install_plugins provider build_sdks install_sdks +only_build:: build + +tfgen:: install_plugins + (cd provider && go build -o $(WORKING_DIR)/bin/${TFGEN} -ldflags "-X ${PROJECT}/${VERSION_PATH}=${VERSION}" ${PROJECT}/${PROVIDER_PATH}/cmd/${TFGEN}) + $(WORKING_DIR)/bin/${TFGEN} schema --out provider/cmd/${PROVIDER} --skip-examples + (cd provider && VERSION=$(VERSION) go generate cmd/${PROVIDER}/main.go) + +provider:: tfgen install_plugins # build the provider binary + (cd provider && go build -o $(WORKING_DIR)/bin/${PROVIDER} -ldflags "-X ${PROJECT}/${VERSION_PATH}=${VERSION}" ${PROJECT}/${PROVIDER_PATH}/cmd/${PROVIDER}) + +generate_sdks:: install_plugins provider build_nodejs build_python build_go build_dotnet #build_java # build all the sdks + +build_nodejs:: VERSION := $(shell pulumictl get version --language javascript) +build_nodejs:: install_plugins tfgen # build the node sdk + $(WORKING_DIR)/bin/$(TFGEN) nodejs --overlays provider/overlays/nodejs --out sdk/nodejs/ --skip-examples + cd sdk/nodejs/ && \ + yarn install && \ + yarn run tsc && \ + cp ../../README.md ../../LICENSE package.json yarn.lock ./bin/ && \ + sed -i.bak -e "s/\$${VERSION}/$(VERSION)/g" ./bin/package.json + +build_python:: PYPI_VERSION := $(shell pulumictl get version --language python) +build_python:: install_plugins tfgen # build the python sdk + $(WORKING_DIR)/bin/$(TFGEN) python --overlays provider/overlays/python --out sdk/python/ --skip-examples + cd sdk/python/ && \ + cp ../../README.md . && \ + python3 setup.py clean --all 2>/dev/null && \ + rm -rf ./bin/ ../python.bin/ && cp -R . ../python.bin && mv ../python.bin ./bin && \ + sed -i.bak -e 's/^VERSION = .*/VERSION = "$(PYPI_VERSION)"/g' -e 's/^PLUGIN_VERSION = .*/PLUGIN_VERSION = "$(VERSION)"/g' ./bin/setup.py && \ + rm ./bin/setup.py.bak && \ + cd ./bin && python3 setup.py build sdist + +build_dotnet:: DOTNET_VERSION := $(shell pulumictl get version --language dotnet) +build_dotnet:: install_plugins tfgen # build the dotnet sdk + pulumictl get version --language dotnet + $(WORKING_DIR)/bin/$(TFGEN) dotnet --overlays provider/overlays/dotnet --out sdk/dotnet/ --skip-examples + cd sdk/dotnet/ && \ + echo "${DOTNET_VERSION}" >version.txt && \ + dotnet build /p:Version=${DOTNET_VERSION} + +build_go:: install_plugins tfgen # build the go sdk + $(WORKING_DIR)/bin/$(TFGEN) go --overlays provider/overlays/go --out sdk/go/ --skip-examples + +build_java:: PACKAGE_VERSION := $(shell pulumictl get version --language generic) +build_java:: $(WORKING_DIR)/bin/$(JAVA_GEN) + $(WORKING_DIR)/bin/$(JAVA_GEN) generate --schema provider/cmd/$(PROVIDER)/schema.json --out sdk/java --build gradle-nexus --skip-examples + cd sdk/java/ && \ + echo "module fake_java_module // Exclude this directory from Go tools\n\ngo 1.17" > go.mod && \ + gradle --console=plain build + +$(WORKING_DIR)/bin/$(JAVA_GEN):: + $(shell pulumictl download-binary -n pulumi-language-java -v $(JAVA_GEN_VERSION) -r pulumi/pulumi-java) + +lint_provider:: provider # lint the provider code + cd provider && golangci-lint run -c ../.golangci.yml + +cleanup:: # cleans up the temporary directory + rm -r $(WORKING_DIR)/bin + rm -f provider/cmd/${PROVIDER}/schema.go + +help:: + @grep '^[^.#]\+:\s\+.*#' Makefile | \ + sed "s/\(.\+\):\s*\(.*\) #\s*\(.*\)/`printf "\033[93m"`\1`printf "\033[0m"` \3 [\2]/" | \ + expand -t20 + +clean:: + rm -rf sdk/{dotnet,nodejs,go,python} + +install_plugins:: + [ -x $(shell which pulumi) ] || curl -fsSL https://get.pulumi.com | sh + pulumi plugin install resource random 4.8.2 + +install_dotnet_sdk:: + mkdir -p $(WORKING_DIR)/nuget + find . -name '*.nupkg' -print -exec cp -p {} ${WORKING_DIR}/nuget \; + +install_python_sdk:: + +install_go_sdk:: + +install_nodejs_sdk:: + yarn --cwd $(WORKING_DIR)/sdk/nodejs/bin link + +install_sdks:: install_dotnet_sdk install_python_sdk install_nodejs_sdk + +test:: + cd examples && go test -v -tags=all -parallel ${TESTPARALLELISM} -timeout 2h + +fmt: + @gofmt -s -w . + +# SETUP AND TOOL INITIALIZATION TASKS +project-help: + @$(SCRIPTS_BASE)/project.sh help + +project-tools: + @$(SCRIPTS_BASE)/project.sh tools diff --git a/README.md b/README.md index bd92725..7fae237 100644 --- a/README.md +++ b/README.md @@ -1 +1,96 @@ -# pulumi-stackit \ No newline at end of file +# STACKIT Pulumi Provider (BETA) + +![logo.svg](docs/logo.svg) + +The STACKIT Pulumi Provider lets you manage [STACKIT](https://www.stackit.de/en/) resources. + +This STACKIT Pulumi Provider is in a BETA state. More functionality will be supported soon. Your feedback is appreciated! Feel free to open GitHub issues to provide feature requests and bug reports. + +## Installing + +This package is available for several languages/platforms: + +### Node.js (JavaScript/TypeScript) + +To use from JavaScript or TypeScript in Node.js, install using either `npm`: + +```bash +npm install @stackitcloud/pulumi-stackit +``` + +or `yarn`: + +```bash +yarn add @stackitcloud/pulumi-stackit +``` + +### Python + +To use from Python, install using `pip`: + +```bash +pip install pulumi_stackit +``` + +### Go + +To use from Go, use `go get` to grab the latest version of the library: + +```bash +go get github.com/stackitcloud/pulumi-stackit/sdk +``` + +### .NET + +To use from .NET, install using `dotnet add package`: + +```bash +dotnet add package Pulumi.stackit +``` + +## Configuration + +The following configuration points are available for the `stackit` provider: + +| Configuration Variable | Environment Variable | Description | +|------------------------|---------------------|-------------| +| `stackit:authorizationCustomEndpoint` | `STACKIT_AUTHORIZATION_CUSTOM_ENDPOINT` | Custom endpoint for the Membership service | +| `stackit:cdnCustomEndpoint` | `STACKIT_CDN_CUSTOM_ENDPOINT` | Custom endpoint for the CDN service | +| `stackit:credentialsPath` | `STACKIT_CREDENTIALS_PATH` | Path of JSON from where the credentials are read. Default value is `~/.stackit/credentials.json` | +| `stackit:defaultRegion` | `STACKIT_DEFAULT_REGION` | Region will be used as the default location for regional services. Not all services require a region, some are global | +| `stackit:dnsCustomEndpoint` | `STACKIT_DNS_CUSTOM_ENDPOINT` | Custom endpoint for the DNS service | +| `stackit:enableBetaResources` | `STACKIT_ENABLE_BETA_RESOURCES` | Enable beta resources. Default is false | +| `stackit:experiments` | `STACKIT_EXPERIMENTS` | Enables experiments. These are unstable features without official support. Available Experiments: [iam] | +| `stackit:gitCustomEndpoint` | `STACKIT_GIT_CUSTOM_ENDPOINT` | Custom endpoint for the Git service | +| `stackit:iaasCustomEndpoint` | `STACKIT_IAAS_CUSTOM_ENDPOINT` | Custom endpoint for the IaaS service | +| `stackit:loadbalancerCustomEndpoint` | `STACKIT_LOADBALANCER_CUSTOM_ENDPOINT` | Custom endpoint for the Load Balancer service | +| `stackit:logmeCustomEndpoint` | `STACKIT_LOGME_CUSTOM_ENDPOINT` | Custom endpoint for the LogMe service | +| `stackit:mariadbCustomEndpoint` | `STACKIT_MARIADB_CUSTOM_ENDPOINT` | Custom endpoint for the MariaDB service | +| `stackit:modelservingCustomEndpoint` | `STACKIT_MODELSERVING_CUSTOM_ENDPOINT` | Custom endpoint for the AI Model Serving service | +| `stackit:mongodbflexCustomEndpoint` | `STACKIT_MONGODBFLEX_CUSTOM_ENDPOINT` | Custom endpoint for the MongoDB Flex service | +| `stackit:objectstorageCustomEndpoint` | `STACKIT_OBJECTSTORAGE_CUSTOM_ENDPOINT` | Custom endpoint for the Object Storage service | +| `stackit:observabilityCustomEndpoint` | `STACKIT_OBSERVABILITY_CUSTOM_ENDPOINT` | Custom endpoint for the Observability service | +| `stackit:opensearchCustomEndpoint` | `STACKIT_OPENSEARCH_CUSTOM_ENDPOINT` | Custom endpoint for the OpenSearch service | +| `stackit:postgresflexCustomEndpoint` | `STACKIT_POSTGRESFLEX_CUSTOM_ENDPOINT` | Custom endpoint for the PostgresFlex service | +| `stackit:privateKey` | `STACKIT_PRIVATE_KEY` | Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is included in the service account key | +| `stackit:privateKeyPath` | `STACKIT_PRIVATE_KEY_PATH` | Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is included in the service account key | +| `stackit:rabbitmqCustomEndpoint` | `STACKIT_RABBITMQ_CUSTOM_ENDPOINT` | Custom endpoint for the RabbitMQ service | +| `stackit:redisCustomEndpoint` | `STACKIT_REDIS_CUSTOM_ENDPOINT` | Custom endpoint for the Redis service | +| `stackit:region` | `STACKIT_REGION` | Region will be used as the default location for regional services. Not all services require a region, some are global ⚠️ **Deprecated**: This attribute is deprecated. Use 'default_region' instead | +| `stackit:resourcemanagerCustomEndpoint` | `STACKIT_RESOURCEMANAGER_CUSTOM_ENDPOINT` | Custom endpoint for the Resource Manager service | +| `stackit:secretsmanagerCustomEndpoint` | `STACKIT_SECRETSMANAGER_CUSTOM_ENDPOINT` | Custom endpoint for the Secrets Manager service | +| `stackit:serverBackupCustomEndpoint` | `STACKIT_SERVER_BACKUP_CUSTOM_ENDPOINT` | Custom endpoint for the Server Backup service | +| `stackit:serverUpdateCustomEndpoint` | `STACKIT_SERVER_UPDATE_CUSTOM_ENDPOINT` | Custom endpoint for the Server Update service | +| `stackit:serviceAccountCustomEndpoint` | `STACKIT_SERVICE_ACCOUNT_CUSTOM_ENDPOINT` | Custom endpoint for the Service Account service | +| `stackit:serviceAccountEmail` | `STACKIT_SERVICE_ACCOUNT_EMAIL` | Service account email. It is required if you want to use the resource manager project resource ⚠️ **Deprecated**: The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025 | +| `stackit:serviceAccountKey` | `STACKIT_SERVICE_ACCOUNT_KEY` | Service account key used for authentication. If set, the key flow will be used to authenticate all operations | +| `stackit:serviceAccountKeyPath` | `STACKIT_SERVICE_ACCOUNT_KEY_PATH` | Path for the service account key used for authentication. If set, the key flow will be used to authenticate all operations | +| `stackit:serviceAccountToken` | `STACKIT_SERVICE_ACCOUNT_TOKEN` | Token used for authentication. If set, the token flow will be used to authenticate all operations | +| `stackit:serviceEnablementCustomEndpoint` | `STACKIT_SERVICE_ENABLEMENT_CUSTOM_ENDPOINT` | Custom endpoint for the Service Enablement API | +| `stackit:skeCustomEndpoint` | `STACKIT_SKE_CUSTOM_ENDPOINT` | Custom endpoint for the Kubernetes Engine (SKE) service | +| `stackit:sqlserverflexCustomEndpoint` | `STACKIT_SQLSERVERFLEX_CUSTOM_ENDPOINT` | Custom endpoint for the SQL Server Flex service | +| `stackit:tokenCustomEndpoint` | `STACKIT_TOKEN_CUSTOM_ENDPOINT` | Custom endpoint for the token API, which is used to request access tokens when using the key flow | + +## Reference + +For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/stackit/api-docs/). diff --git a/docs/logo.svg b/docs/logo.svg new file mode 100644 index 0000000..c53eee9 --- /dev/null +++ b/docs/logo.svg @@ -0,0 +1,174 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/examples/dotnet/getNetwork/Program.cs b/examples/dotnet/getNetwork/Program.cs new file mode 100644 index 0000000..6d6bccd --- /dev/null +++ b/examples/dotnet/getNetwork/Program.cs @@ -0,0 +1,25 @@ +using System.Collections.Generic; +using Pulumi; +using Pulumi.Stackit; + +return await Deployment.RunAsync(async () => +{ + // Replace with your actual project ID and network ID + string projectId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; + string networkId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; + + // Create arguments for getting the network + var args = new GetNetworkArgs + { + ProjectId = projectId, + NetworkId = networkId + }; + + var networkResult = await GetNetwork.InvokeAsync(args); + + // Export outputs here + return new Dictionary + { + ["outputKey"] = networkResult.Name + }; +}); diff --git a/examples/dotnet/getNetwork/Pulumi.yaml b/examples/dotnet/getNetwork/Pulumi.yaml new file mode 100644 index 0000000..8e06d4d --- /dev/null +++ b/examples/dotnet/getNetwork/Pulumi.yaml @@ -0,0 +1,7 @@ +name: getNetworkExample +description: A minimal C# Pulumi program +runtime: dotnet +config: + pulumi:tags: + value: + pulumi:template: csharp diff --git a/examples/dotnet/getNetwork/getNetwork.csproj b/examples/dotnet/getNetwork/getNetwork.csproj new file mode 100644 index 0000000..4b6d27e --- /dev/null +++ b/examples/dotnet/getNetwork/getNetwork.csproj @@ -0,0 +1,14 @@ + + + + Exe + net8.0 + enable + + + + + + + + diff --git a/examples/go.mod b/examples/go.mod new file mode 100644 index 0000000..c570872 --- /dev/null +++ b/examples/go.mod @@ -0,0 +1,7 @@ +module github.com/stackitcloud/pulumi-stackit/examples + +go 1.23.0 + +toolchain go1.23.10 + +replace github.com/hashicorp/terraform-plugin-sdk/v2 => github.com/pulumi/terraform-plugin-sdk/v2 v2.0.0-20250530111747-935112552988 diff --git a/examples/go/Pulumi.yaml b/examples/go/Pulumi.yaml new file mode 100644 index 0000000..e2e2a33 --- /dev/null +++ b/examples/go/Pulumi.yaml @@ -0,0 +1,7 @@ +name: stackit-go +description: A minimal Go Pulumi program +runtime: go +plugins: + providers: + - name: stackit + path: ../../bin diff --git a/examples/go/go.mod b/examples/go/go.mod new file mode 100644 index 0000000..1473cbc --- /dev/null +++ b/examples/go/go.mod @@ -0,0 +1,96 @@ +module stackit-go + +go 1.23.0 + +toolchain go1.24.2 + +require ( + github.com/stackitcloud/pulumi-stackit/sdk v0.1.0 + github.com/pulumi/pulumi/sdk/v3 v3.181.0 +) + +replace github.com/stackitcloud/pulumi-stackit/sdk => ../../sdk + +require ( + dario.cat/mergo v1.0.0 // indirect + github.com/BurntSushi/toml v1.2.1 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/ProtonMail/go-crypto v1.1.3 // indirect + github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect + github.com/agext/levenshtein v1.2.3 // indirect + github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect + github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect + github.com/atotto/clipboard v0.1.4 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/blang/semver v3.5.1+incompatible // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.25.0 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect + github.com/cheggaaa/pb v1.0.29 // indirect + github.com/cloudflare/circl v1.6.1 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect + github.com/cyphar/filepath-securejoin v0.3.6 // indirect + github.com/djherbis/times v1.5.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect + github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect + github.com/go-git/go-billy/v5 v5.6.1 // indirect + github.com/go-git/go-git/v5 v5.13.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/glog v1.2.4 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 // indirect + github.com/hashicorp/errwrap v1.1.0 // indirect + github.com/hashicorp/go-multierror v1.1.1 // indirect + github.com/hashicorp/hcl/v2 v2.22.0 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/kevinburke/ssh_config v1.2.0 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.15 // indirect + github.com/mitchellh/go-ps v1.0.0 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.2 // indirect + github.com/opentracing/basictracer-go v1.1.0 // indirect + github.com/opentracing/opentracing-go v1.2.0 // indirect + github.com/pgavlin/fx v0.1.6 // indirect + github.com/pjbgf/sha1cd v0.3.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pkg/term v1.1.0 // indirect + github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 // indirect + github.com/pulumi/esc v0.14.3 // indirect + github.com/rivo/uniseg v0.4.4 // indirect + github.com/rogpeppe/go-internal v1.12.0 // indirect + github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect + github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect + github.com/skeema/knownhosts v1.3.0 // indirect + github.com/spf13/cobra v1.8.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/texttheater/golang-levenshtein v1.0.1 // indirect + github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect + github.com/uber/jaeger-lib v2.4.1+incompatible // indirect + github.com/xanzy/ssh-agent v0.3.3 // indirect + github.com/zclconf/go-cty v1.13.2 // indirect + go.uber.org/atomic v1.9.0 // indirect + golang.org/x/crypto v0.39.0 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.40.0 // indirect + golang.org/x/sync v0.15.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/term v0.32.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/tools v0.33.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect + google.golang.org/grpc v1.67.1 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + lukechampine.com/frand v1.4.2 // indirect +) diff --git a/examples/go/go.sum b/examples/go/go.sum new file mode 100644 index 0000000..e3fdf75 --- /dev/null +++ b/examples/go/go.sum @@ -0,0 +1,282 @@ +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= +github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/HdrHistogram/hdrhistogram-go v1.1.2 h1:5IcZpTvzydCQeHzK4Ef/D5rrSqwxob0t8PQPMybUNFM= +github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= +github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk= +github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA= +github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo= +github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw= +github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo= +github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY= +github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= +github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.25.0 h1:bAfwk7jRz7FKFl9RzlIULPkStffg5k6pNt5dywy4TcM= +github.com/charmbracelet/bubbletea v0.25.0/go.mod h1:EN3QDR1T5ZdWmdfDzYcqOCAps45+QIJbLOBxmVNWNNg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= +github.com/cheggaaa/pb v1.0.29 h1:FckUN5ngEk2LpvuG0fw1GEFx6LtyY2pWI/Z2QgCnEYo= +github.com/cheggaaa/pb v1.0.29/go.mod h1:W40334L7FMC5JKWldsTWbdGjLo0RxUKK73K+TuPxX30= +github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0= +github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= +github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM= +github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/djherbis/times v1.5.0 h1:79myA211VwPhFTqUk8xehWrsEO+zcIZj0zT8mXPVARU= +github.com/djherbis/times v1.5.0/go.mod h1:5q7FDLvbNg1L/KaBmPcWlVR9NmoKo3+ucqUA3ijQhA0= +github.com/elazarl/goproxy v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ= +github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= +github.com/go-git/go-billy/v5 v5.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA= +github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= +github.com/go-git/go-git/v5 v5.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M= +github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/glog v1.2.4 h1:CNNw5U8lSiiBk7druxtSHHTsRWcxKoac6kZKm2peBBc= +github.com/golang/glog v1.2.4/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 h1:MJG/KsmcqMwFAkh8mTnAwhyKoB+sTAnY4CACC110tbU= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hashicorp/hcl/v2 v2.22.0 h1:hkZ3nCtqeJsDhPRFz5EA9iwcG1hNWGePOTw6oyul12M= +github.com/hashicorp/hcl/v2 v2.22.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= +github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= +github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc= +github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= +github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= +github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= +github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= +github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= +github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +github.com/opentracing/basictracer-go v1.1.0 h1:Oa1fTSBvAl8pa3U+IJYqrKm0NALwH9OsgwOqDv4xJW0= +github.com/opentracing/basictracer-go v1.1.0/go.mod h1:V2HZueSJEp879yv285Aap1BS69fQMD+MNP1mRs6mBQc= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/pgavlin/fx v0.1.6 h1:r9jEg69DhNoCd3Xh0+5mIbdbS3PqWrVWujkY76MFRTU= +github.com/pgavlin/fx v0.1.6/go.mod h1:KWZJ6fqBBSh8GxHYqwYCf3rYE7Gp2p0N8tJp8xv9u9M= +github.com/pgavlin/fx/v2 v2.0.3 h1:ZBVklTFjxcWvBVPE+ti5qwnmTIQ0Gq6nuj3J5RKDtKk= +github.com/pgavlin/fx/v2 v2.0.3/go.mod h1:Cvnwqq0BopdHUJ7CU50h1XPeKrF4ZwdFj1nJLXbAjCE= +github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4= +github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/term v1.1.0 h1:xIAAdCMh3QIAy+5FrE8Ad8XoDhEU4ufwbaSozViP9kk= +github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 h1:vkHw5I/plNdTr435cARxCW6q9gc0S/Yxz7Mkd38pOb0= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231/go.mod h1:murToZ2N9hNJzewjHBgfFdXhZKjY3z5cYC1VXk+lbFE= +github.com/pulumi/esc v0.14.3 h1:Zli+9LiSDT/W+Fsfr8tITxCo+5wn969tLrE4KLv44G8= +github.com/pulumi/esc v0.14.3/go.mod h1:XnSxlt5NkmuAj304l/gK4pRErFbtqq6XpfX1tYT9Jbc= +github.com/pulumi/pulumi/sdk/v3 v3.181.0 h1:6XeYlG/mymtutRXlggcCLtxqBJPGCHNUGgoj4mapZQw= +github.com/pulumi/pulumi/sdk/v3 v3.181.0/go.mod h1:YS7uQ+eoIV/Fco804Upv3jmz5pwo/MkLYmbGH3VgA9c= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= +github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 h1:TToq11gyfNlrMFZiYujSekIsPd9AmsA2Bj/iv+s4JHE= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0/go.mod h1:FKdcjfQW6rpZSnxxUvEA5H/cDPdvJ/SZJQLWWXWGrZ0= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY= +github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M= +github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0= +github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/texttheater/golang-levenshtein v1.0.1 h1:+cRNoVrfiwufQPhoMzB6N0Yf/Mqajr6t1lOv8GyGE2U= +github.com/texttheater/golang-levenshtein v1.0.1/go.mod h1:PYAKrbF5sAiq9wd+H82hs7gNaen0CplQ9uvm6+enD/8= +github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o= +github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk= +github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg= +github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U= +github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= +github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/zclconf/go-cty v1.13.2 h1:4GvrUxe/QUDYuJKAav4EYqdM47/kZa672LwmXFmEKT0= +github.com/zclconf/go-cty v1.13.2/go.mod h1:YKQzy/7pZ7iq2jNFzy5go57xdxdWoLLpaEp4u238AE0= +go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= +golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8= +golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg= +golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc= +golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E= +google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +lukechampine.com/frand v1.4.2 h1:RzFIpOvkMXuPMBb9maa4ND4wjBn71E1Jpf8BzJHMaVw= +lukechampine.com/frand v1.4.2/go.mod h1:4S/TM2ZgrKejMcKMbeLjISpJMO+/eZ1zu3vYX9dtj3s= +pgregory.net/rapid v0.5.5 h1:jkgx1TjbQPD/feRoK+S/mXw9e1uj6WilpHrXJowi6oA= +pgregory.net/rapid v0.5.5/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= diff --git a/examples/go/main.go b/examples/go/main.go new file mode 100644 index 0000000..8891873 --- /dev/null +++ b/examples/go/main.go @@ -0,0 +1,28 @@ +package main + +import ( + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit" +) + +func main() { + pulumi.Run(func(ctx *pulumi.Context) error { + + distribution, err := stackit.NewCdnDistribution(ctx, "cdn", &stackit.CdnDistributionArgs{ + Config: stackit.CdnDistributionConfigArgs{ + Regions: pulumi.StringArray{pulumi.String("EU")}, + Backend: stackit.CdnDistributionConfigBackendArgs{ + Type: pulumi.String("http"), + OriginUrl: pulumi.String("https://example.com"), + }, + }, + ProjectId: pulumi.String("00000000-0000-0000-0000-000000000000"), // Replace with your actual project ID + }) + if err != nil { + return err + } + ctx.Export("cdnDistributionId", distribution.ID()) + + return nil + }) +} diff --git a/examples/ts/.gitignore b/examples/ts/.gitignore new file mode 100644 index 0000000..c695889 --- /dev/null +++ b/examples/ts/.gitignore @@ -0,0 +1,2 @@ +/bin/ +/node_modules/ diff --git a/examples/ts/Pulumi.yaml b/examples/ts/Pulumi.yaml new file mode 100644 index 0000000..721b245 --- /dev/null +++ b/examples/ts/Pulumi.yaml @@ -0,0 +1,10 @@ +name: example-ts +description: A minimal TypeScript Pulumi program +runtime: + name: nodejs + options: + packagemanager: npm +config: + pulumi:tags: + value: + pulumi:template: typescript diff --git a/examples/ts/index.ts b/examples/ts/index.ts new file mode 100644 index 0000000..bc40a2e --- /dev/null +++ b/examples/ts/index.ts @@ -0,0 +1,16 @@ +import * as stackit from "@stackitcloud/pulumi-stackit"; + +const distribution = new stackit.CdnDistribution("cdn-distribution", { + config: { + regions: [ + "EU" + ], + backend: { + type: "http", + originUrl: "https://example.com", + } + }, + projectId: "00000000-0000-0000-0000-000000000000", +}) + +export const distributionId = distribution.id; diff --git a/examples/ts/package-lock.json b/examples/ts/package-lock.json new file mode 100644 index 0000000..389c113 --- /dev/null +++ b/examples/ts/package-lock.json @@ -0,0 +1,3407 @@ +{ + "name": "example-ts", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "example-ts", + "dependencies": { + "@stackitcloud/pulumi-stackit": "^0.1.2", + "@pulumi/pulumi": "^3.113.0" + }, + "devDependencies": { + "@types/node": "^18", + "typescript": "^5.0.0" + } + }, + "node_modules/@stackitcloud/pulumi-stackit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/@stackitcloud/pulumi-stackit/-/pulumi-stackit-0.1.2.tgz", + "integrity": "sha512-180Mtm9WuScexxcDkQ4R28na0FviXwDpOmgp4324pboujmRm5zjJhFcKCns0d3A3ZhEGP8Uz5ENuhLXekB6Hag==", + "license": "Apache-2.0", + "dependencies": { + "@pulumi/pulumi": "^3.0.0" + } + }, + "node_modules/@grpc/grpc-js": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.13.4.tgz", + "integrity": "sha512-GsFaMXCkMqkKIvwCQjCrwH+GHbPKBjhwo/8ZuUkWHqbI73Kky9I+pQltrlT0+MWpedCoosda53lgjYfyEPgxBg==", + "license": "Apache-2.0", + "dependencies": { + "@grpc/proto-loader": "^0.7.13", + "@js-sdsl/ordered-map": "^4.4.2" + }, + "engines": { + "node": ">=12.10.0" + } + }, + "node_modules/@grpc/proto-loader": { + "version": "0.7.15", + "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz", + "integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==", + "license": "Apache-2.0", + "dependencies": { + "lodash.camelcase": "^4.3.0", + "long": "^5.0.0", + "protobufjs": "^7.2.5", + "yargs": "^17.7.2" + }, + "bin": { + "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "license": "ISC", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@isaacs/string-locale-compare": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@isaacs/string-locale-compare/-/string-locale-compare-1.1.0.tgz", + "integrity": "sha512-SQ7Kzhh9+D+ZW9MA0zkYv3VXhIDNx+LzM6EJ+/65I3QY+enU6Itte7E5XX7EWrqLW2FN4n06GWzBnPoC3th2aQ==", + "license": "ISC" + }, + "node_modules/@js-sdsl/ordered-map": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz", + "integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/js-sdsl" + } + }, + "node_modules/@logdna/tail-file": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@logdna/tail-file/-/tail-file-2.2.0.tgz", + "integrity": "sha512-XGSsWDweP80Fks16lwkAUIr54ICyBs6PsI4mpfTLQaWgEJRtY9xEV+PeyDpJ+sJEGZxqINlpmAwe/6tS1pP8Ng==", + "license": "SEE LICENSE IN LICENSE", + "engines": { + "node": ">=10.3.0" + } + }, + "node_modules/@npmcli/agent": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/@npmcli/agent/-/agent-2.2.2.tgz", + "integrity": "sha512-OrcNPXdpSl9UX7qPVRWbmWMCSXrcDa2M9DvrbOTj7ao1S4PlqVFYv9/yLKMkrJKZ/V5A/kDBC690or307i26Og==", + "license": "ISC", + "dependencies": { + "agent-base": "^7.1.0", + "http-proxy-agent": "^7.0.0", + "https-proxy-agent": "^7.0.1", + "lru-cache": "^10.0.1", + "socks-proxy-agent": "^8.0.3" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/arborist": { + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/@npmcli/arborist/-/arborist-7.5.4.tgz", + "integrity": "sha512-nWtIc6QwwoUORCRNzKx4ypHqCk3drI+5aeYdMTQQiRCcn4lOOgfQh7WyZobGYTxXPSq1VwV53lkpN/BRlRk08g==", + "license": "ISC", + "dependencies": { + "@isaacs/string-locale-compare": "^1.1.0", + "@npmcli/fs": "^3.1.1", + "@npmcli/installed-package-contents": "^2.1.0", + "@npmcli/map-workspaces": "^3.0.2", + "@npmcli/metavuln-calculator": "^7.1.1", + "@npmcli/name-from-folder": "^2.0.0", + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.1.0", + "@npmcli/query": "^3.1.0", + "@npmcli/redact": "^2.0.0", + "@npmcli/run-script": "^8.1.0", + "bin-links": "^4.0.4", + "cacache": "^18.0.3", + "common-ancestor-path": "^1.0.1", + "hosted-git-info": "^7.0.2", + "json-parse-even-better-errors": "^3.0.2", + "json-stringify-nice": "^1.1.4", + "lru-cache": "^10.2.2", + "minimatch": "^9.0.4", + "nopt": "^7.2.1", + "npm-install-checks": "^6.2.0", + "npm-package-arg": "^11.0.2", + "npm-pick-manifest": "^9.0.1", + "npm-registry-fetch": "^17.0.1", + "pacote": "^18.0.6", + "parse-conflict-json": "^3.0.0", + "proc-log": "^4.2.0", + "proggy": "^2.0.0", + "promise-all-reject-late": "^1.0.0", + "promise-call-limit": "^3.0.1", + "read-package-json-fast": "^3.0.2", + "semver": "^7.3.7", + "ssri": "^10.0.6", + "treeverse": "^3.0.0", + "walk-up-path": "^3.0.1" + }, + "bin": { + "arborist": "bin/index.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/fs": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-3.1.1.tgz", + "integrity": "sha512-q9CRWjpHCMIh5sVyefoD1cA7PkvILqCZsnSOEUUivORLjxCO/Irmue2DprETiNgEqktDBZaM1Bi+jrarx1XdCg==", + "license": "ISC", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/git": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/@npmcli/git/-/git-5.0.8.tgz", + "integrity": "sha512-liASfw5cqhjNW9UFd+ruwwdEf/lbOAQjLL2XY2dFW/bkJheXDYZgOyul/4gVvEV4BWkTXjYGmDqMw9uegdbJNQ==", + "license": "ISC", + "dependencies": { + "@npmcli/promise-spawn": "^7.0.0", + "ini": "^4.1.3", + "lru-cache": "^10.0.1", + "npm-pick-manifest": "^9.0.0", + "proc-log": "^4.0.0", + "promise-inflight": "^1.0.1", + "promise-retry": "^2.0.1", + "semver": "^7.3.5", + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/git/node_modules/ini": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.3.tgz", + "integrity": "sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/installed-package-contents": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/installed-package-contents/-/installed-package-contents-2.1.0.tgz", + "integrity": "sha512-c8UuGLeZpm69BryRykLuKRyKFZYJsZSCT4aVY5ds4omyZqJ172ApzgfKJ5eV/r3HgLdUYgFVe54KSFVjKoe27w==", + "license": "ISC", + "dependencies": { + "npm-bundled": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "bin": { + "installed-package-contents": "bin/index.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/map-workspaces": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@npmcli/map-workspaces/-/map-workspaces-3.0.6.tgz", + "integrity": "sha512-tkYs0OYnzQm6iIRdfy+LcLBjcKuQCeE5YLb8KnrIlutJfheNaPvPpgoFEyEFgbjzl5PLZ3IA/BWAwRU0eHuQDA==", + "license": "ISC", + "dependencies": { + "@npmcli/name-from-folder": "^2.0.0", + "glob": "^10.2.2", + "minimatch": "^9.0.0", + "read-package-json-fast": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/metavuln-calculator": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@npmcli/metavuln-calculator/-/metavuln-calculator-7.1.1.tgz", + "integrity": "sha512-Nkxf96V0lAx3HCpVda7Vw4P23RILgdi/5K1fmj2tZkWIYLpXAN8k2UVVOsW16TsS5F8Ws2I7Cm+PU1/rsVF47g==", + "license": "ISC", + "dependencies": { + "cacache": "^18.0.0", + "json-parse-even-better-errors": "^3.0.0", + "pacote": "^18.0.0", + "proc-log": "^4.1.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/name-from-folder": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@npmcli/name-from-folder/-/name-from-folder-2.0.0.tgz", + "integrity": "sha512-pwK+BfEBZJbKdNYpHHRTNBwBoqrN/iIMO0AiGvYsp3Hoaq0WbgGSWQR6SCldZovoDpY3yje5lkFUe6gsDgJ2vg==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/node-gyp": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@npmcli/node-gyp/-/node-gyp-3.0.0.tgz", + "integrity": "sha512-gp8pRXC2oOxu0DUE1/M3bYtb1b3/DbJ5aM113+XJBgfXdussRAsX0YOrOhdd8WvnAR6auDBvJomGAkLKA5ydxA==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/package-json": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/@npmcli/package-json/-/package-json-5.2.1.tgz", + "integrity": "sha512-f7zYC6kQautXHvNbLEWgD/uGu1+xCn9izgqBfgItWSx22U0ZDekxN08A1vM8cTxj/cRVe0Q94Ode+tdoYmIOOQ==", + "license": "ISC", + "dependencies": { + "@npmcli/git": "^5.0.0", + "glob": "^10.2.2", + "hosted-git-info": "^7.0.0", + "json-parse-even-better-errors": "^3.0.0", + "normalize-package-data": "^6.0.0", + "proc-log": "^4.0.0", + "semver": "^7.5.3" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/promise-spawn": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/@npmcli/promise-spawn/-/promise-spawn-7.0.2.tgz", + "integrity": "sha512-xhfYPXoV5Dy4UkY0D+v2KkwvnDfiA/8Mt3sWCGI/hM03NsYIH8ZaG6QzS9x7pje5vHZBZJ2v6VRFVTWACnqcmQ==", + "license": "ISC", + "dependencies": { + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/query": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/query/-/query-3.1.0.tgz", + "integrity": "sha512-C/iR0tk7KSKGldibYIB9x8GtO/0Bd0I2mhOaDb8ucQL/bQVTmGoeREaFj64Z5+iCBRf3dQfed0CjJL7I8iTkiQ==", + "license": "ISC", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/redact": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@npmcli/redact/-/redact-2.0.1.tgz", + "integrity": "sha512-YgsR5jCQZhVmTJvjduTOIHph0L73pK8xwMVaDY0PatySqVM9AZj93jpoXYSJqfHFxFkN9dmqTw6OiqExsS3LPw==", + "license": "ISC", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@npmcli/run-script": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@npmcli/run-script/-/run-script-8.1.0.tgz", + "integrity": "sha512-y7efHHwghQfk28G2z3tlZ67pLG0XdfYbcVG26r7YIXALRsrVQcTq4/tdenSmdOrEsNahIYA/eh8aEVROWGFUDg==", + "license": "ISC", + "dependencies": { + "@npmcli/node-gyp": "^3.0.0", + "@npmcli/package-json": "^5.0.0", + "@npmcli/promise-spawn": "^7.0.0", + "node-gyp": "^10.0.0", + "proc-log": "^4.0.0", + "which": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@opentelemetry/api": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", + "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@opentelemetry/api-logs": { + "version": "0.55.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/api-logs/-/api-logs-0.55.0.tgz", + "integrity": "sha512-3cpa+qI45VHYcA5c0bHM6VHo9gicv3p5mlLHNG3rLyjQU8b7e0st1rWtrUn3JbZ3DwwCfhKop4eQ9UuYlC6Pkg==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/api": "^1.3.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@opentelemetry/context-async-hooks": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-1.30.1.tgz", + "integrity": "sha512-s5vvxXPVdjqS3kTLKMeBMvop9hbWkwzBpu+mUO2M7sZtlkyDJGwFe33wRKnbaYDo8ExRVBIIdwIGrqpxHuKttA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/core": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-1.30.1.tgz", + "integrity": "sha512-OOCM2C/QIURhJMuKaekP3TRBxBKxG/TWWA0TL2J6nXUtDnuCtccy49LUJF8xPFXMX+0LMcxFpCo8M9cGY1W6rQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/exporter-zipkin": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/exporter-zipkin/-/exporter-zipkin-1.30.1.tgz", + "integrity": "sha512-6S2QIMJahIquvFaaxmcwpvQQRD/YFaMTNoIxrfPIPOeITN+a8lfEcPDxNxn8JDAaxkg+4EnXhz8upVDYenoQjA==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/resources": "1.30.1", + "@opentelemetry/sdk-trace-base": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.0.0" + } + }, + "node_modules/@opentelemetry/instrumentation": { + "version": "0.55.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/instrumentation/-/instrumentation-0.55.0.tgz", + "integrity": "sha512-YDCMlaQRZkziLL3t6TONRgmmGxDx6MyQDXRD0dknkkgUZtOK5+8MWft1OXzmNu6XfBOdT12MKN5rz+jHUkafKQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/api-logs": "0.55.0", + "@types/shimmer": "^1.2.0", + "import-in-the-middle": "^1.8.1", + "require-in-the-middle": "^7.1.1", + "semver": "^7.5.2", + "shimmer": "^1.2.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.3.0" + } + }, + "node_modules/@opentelemetry/instrumentation-grpc": { + "version": "0.55.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/instrumentation-grpc/-/instrumentation-grpc-0.55.0.tgz", + "integrity": "sha512-n2ZH4pRwOy0Vhag/3eKqiyDBwcpUnGgJI9iiIRX7vivE0FMncaLazWphNFezRRaM/LuKwq1TD8pVUvieP68mow==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/instrumentation": "0.55.0", + "@opentelemetry/semantic-conventions": "1.27.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.3.0" + } + }, + "node_modules/@opentelemetry/instrumentation-grpc/node_modules/@opentelemetry/semantic-conventions": { + "version": "1.27.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.27.0.tgz", + "integrity": "sha512-sAay1RrB+ONOem0OZanAR1ZI/k7yDpnOQSQmTMuGImUQb2y8EbSaCJ94FQluM74xoU03vlb2d2U90hZluL6nQg==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + } + }, + "node_modules/@opentelemetry/propagator-b3": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-b3/-/propagator-b3-1.30.1.tgz", + "integrity": "sha512-oATwWWDIJzybAZ4pO76ATN5N6FFbOA1otibAVlS8v90B4S1wClnhRUk7K+2CHAwN1JKYuj4jh/lpCEG5BAqFuQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/propagator-jaeger": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/propagator-jaeger/-/propagator-jaeger-1.30.1.tgz", + "integrity": "sha512-Pj/BfnYEKIOImirH76M4hDaBSx6HyZ2CXUqk+Kj02m6BB80c/yo4BdWkn/1gDFfU+YPY+bPR2U0DKBfdxCKwmg==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/resources": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-1.30.1.tgz", + "integrity": "sha512-5UxZqiAgLYGFjS4s9qm5mBVo433u+dSPUFWVWXmLAD4wB65oMCoXaJP1KJa9DIYYMeHu3z4BZcStG3LC593cWA==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/sdk-trace-base": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-1.30.1.tgz", + "integrity": "sha512-jVPgBbH1gCy2Lb7X0AVQ8XAfgg0pJ4nvl8/IiQA6nxOsPvS+0zMJaFSs2ltXe0J6C8dqjcnpyqINDJmU30+uOg==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/core": "1.30.1", + "@opentelemetry/resources": "1.30.1", + "@opentelemetry/semantic-conventions": "1.28.0" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/sdk-trace-node": { + "version": "1.30.1", + "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-1.30.1.tgz", + "integrity": "sha512-cBjYOINt1JxXdpw1e5MlHmFRc5fgj4GW/86vsKFxJCJ8AL4PdVtYH41gWwl4qd4uQjqEL1oJVrXkSy5cnduAnQ==", + "license": "Apache-2.0", + "dependencies": { + "@opentelemetry/context-async-hooks": "1.30.1", + "@opentelemetry/core": "1.30.1", + "@opentelemetry/propagator-b3": "1.30.1", + "@opentelemetry/propagator-jaeger": "1.30.1", + "@opentelemetry/sdk-trace-base": "1.30.1", + "semver": "^7.5.2" + }, + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "@opentelemetry/api": ">=1.0.0 <1.10.0" + } + }, + "node_modules/@opentelemetry/semantic-conventions": { + "version": "1.28.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.28.0.tgz", + "integrity": "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + } + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "node_modules/@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "license": "BSD-3-Clause" + }, + "node_modules/@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "license": "BSD-3-Clause" + }, + "node_modules/@pulumi/pulumi": { + "version": "3.181.0", + "resolved": "https://registry.npmjs.org/@pulumi/pulumi/-/pulumi-3.181.0.tgz", + "integrity": "sha512-2Qrqpubcqdc9oHF1gacY6Ho8FGwPxvico1B+PexGABq2k4v4qxgP8pc5GS4SfzBHOQc10jpOfe9UziLs9w9x2Q==", + "license": "Apache-2.0", + "dependencies": { + "@grpc/grpc-js": "^1.10.1", + "@logdna/tail-file": "^2.0.6", + "@npmcli/arborist": "^7.3.1", + "@opentelemetry/api": "^1.9", + "@opentelemetry/exporter-zipkin": "^1.28", + "@opentelemetry/instrumentation": "^0.55", + "@opentelemetry/instrumentation-grpc": "^0.55", + "@opentelemetry/resources": "^1.28", + "@opentelemetry/sdk-trace-base": "^1.28", + "@opentelemetry/sdk-trace-node": "^1.28", + "@types/google-protobuf": "^3.15.5", + "@types/semver": "^7.5.6", + "@types/tmp": "^0.2.6", + "execa": "^5.1.0", + "fdir": "^6.1.1", + "google-protobuf": "^3.5.0", + "got": "^11.8.6", + "ini": "^2.0.0", + "js-yaml": "^3.14.0", + "minimist": "^1.2.6", + "normalize-package-data": "^6.0.0", + "picomatch": "^3.0.1", + "pkg-dir": "^7.0.0", + "require-from-string": "^2.0.1", + "semver": "^7.5.2", + "source-map-support": "^0.5.6", + "tmp": "^0.2.1", + "upath": "^1.1.0" + }, + "engines": { + "node": ">=20" + }, + "peerDependencies": { + "ts-node": ">= 7.0.1 < 12", + "typescript": ">= 3.8.3 < 6" + }, + "peerDependenciesMeta": { + "ts-node": { + "optional": true + }, + "typescript": { + "optional": true + } + } + }, + "node_modules/@sigstore/bundle": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@sigstore/bundle/-/bundle-2.3.2.tgz", + "integrity": "sha512-wueKWDk70QixNLB363yHc2D2ItTgYiMTdPwK8D9dKQMR3ZQ0c35IxP5xnwQ8cNLoCgCRcHf14kE+CLIvNX1zmA==", + "license": "Apache-2.0", + "dependencies": { + "@sigstore/protobuf-specs": "^0.3.2" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/core": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@sigstore/core/-/core-1.1.0.tgz", + "integrity": "sha512-JzBqdVIyqm2FRQCulY6nbQzMpJJpSiJ8XXWMhtOX9eKgaXXpfNOF53lzQEjIydlStnd/eFtuC1dW4VYdD93oRg==", + "license": "Apache-2.0", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/protobuf-specs": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.3.3.tgz", + "integrity": "sha512-RpacQhBlwpBWd7KEJsRKcBQalbV28fvkxwTOJIqhIuDysMMaJW47V4OqW30iJB9uRpqOSxxEAQFdr8tTattReQ==", + "license": "Apache-2.0", + "engines": { + "node": "^18.17.0 || >=20.5.0" + } + }, + "node_modules/@sigstore/sign": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/@sigstore/sign/-/sign-2.3.2.tgz", + "integrity": "sha512-5Vz5dPVuunIIvC5vBb0APwo7qKA4G9yM48kPWJT+OEERs40md5GoUR1yedwpekWZ4m0Hhw44m6zU+ObsON+iDA==", + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.2", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.2", + "make-fetch-happen": "^13.0.1", + "proc-log": "^4.2.0", + "promise-retry": "^2.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/tuf": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/@sigstore/tuf/-/tuf-2.3.4.tgz", + "integrity": "sha512-44vtsveTPUpqhm9NCrbU8CWLe3Vck2HO1PNLw7RIajbB7xhtn5RBPm1VNSCMwqGYHhDsBJG8gDF0q4lgydsJvw==", + "license": "Apache-2.0", + "dependencies": { + "@sigstore/protobuf-specs": "^0.3.2", + "tuf-js": "^2.2.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@sigstore/verify": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@sigstore/verify/-/verify-1.2.1.tgz", + "integrity": "sha512-8iKx79/F73DKbGfRf7+t4dqrc0bRr0thdPrxAtCKWRm/F0tG71i6O1rvlnScncJLLBZHn3h8M3c1BSUAb9yu8g==", + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.2", + "@sigstore/core": "^1.1.0", + "@sigstore/protobuf-specs": "^0.3.2" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@sindresorhus/is": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz", + "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz", + "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==", + "license": "MIT", + "dependencies": { + "defer-to-connect": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@tufjs/canonical-json": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@tufjs/canonical-json/-/canonical-json-2.0.0.tgz", + "integrity": "sha512-yVtV8zsdo8qFHe+/3kw81dSLyF7D576A5cCFCi4X7B39tWT7SekaEFUnvnWJHz+9qO7qJTah1JbrDjWKqFtdWA==", + "license": "MIT", + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@tufjs/models": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@tufjs/models/-/models-2.0.1.tgz", + "integrity": "sha512-92F7/SFyufn4DXsha9+QfKnN03JGqtMFMXgSHbZOo8JG59WkTni7UzAouNQDf7AuP9OAMxVOPQcqG3sB7w+kkg==", + "license": "MIT", + "dependencies": { + "@tufjs/canonical-json": "2.0.0", + "minimatch": "^9.0.4" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/@types/cacheable-request": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz", + "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==", + "license": "MIT", + "dependencies": { + "@types/http-cache-semantics": "*", + "@types/keyv": "^3.1.4", + "@types/node": "*", + "@types/responselike": "^1.0.0" + } + }, + "node_modules/@types/google-protobuf": { + "version": "3.15.12", + "resolved": "https://registry.npmjs.org/@types/google-protobuf/-/google-protobuf-3.15.12.tgz", + "integrity": "sha512-40um9QqwHjRS92qnOaDpL7RmDK15NuZYo9HihiJRbYkMQZlWnuH8AdvbMy8/o6lgLmKbDUKa+OALCltHdbOTpQ==", + "license": "MIT" + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz", + "integrity": "sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==", + "license": "MIT" + }, + "node_modules/@types/keyv": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz", + "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/node": { + "version": "18.19.113", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.113.tgz", + "integrity": "sha512-TmSTE9vyebJ9vSEiU+P+0Sp4F5tMgjiEOZaQUW6wA3ODvi6uBgkHQ+EsIu0pbiKvf9QHEvyRCiaz03rV0b+IaA==", + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/responselike": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz", + "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/semver": { + "version": "7.7.0", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.0.tgz", + "integrity": "sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA==", + "license": "MIT" + }, + "node_modules/@types/shimmer": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@types/shimmer/-/shimmer-1.2.0.tgz", + "integrity": "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg==", + "license": "MIT" + }, + "node_modules/@types/tmp": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/@types/tmp/-/tmp-0.2.6.tgz", + "integrity": "sha512-chhaNf2oKHlRkDGt+tiKE2Z5aJ6qalm7Z9rlLdBwmOiAAf09YQvvoLXjWK4HWPF1xU/fqvMgfNfpVoBscA/tKA==", + "license": "MIT" + }, + "node_modules/abbrev": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz", + "integrity": "sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/acorn": { + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-import-attributes": { + "version": "1.9.5", + "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz", + "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==", + "license": "MIT", + "peerDependencies": { + "acorn": "^8" + } + }, + "node_modules/agent-base": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz", + "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==", + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "license": "MIT", + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "license": "MIT", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/bin-links": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/bin-links/-/bin-links-4.0.4.tgz", + "integrity": "sha512-cMtq4W5ZsEwcutJrVId+a/tjt8GSbS+h0oNkdl6+6rBuEv8Ot33Bevj5KPm40t309zuhVic8NjpuL42QCiJWWA==", + "license": "ISC", + "dependencies": { + "cmd-shim": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "read-cmd-shim": "^4.0.0", + "write-file-atomic": "^5.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "license": "MIT" + }, + "node_modules/cacache": { + "version": "18.0.4", + "resolved": "https://registry.npmjs.org/cacache/-/cacache-18.0.4.tgz", + "integrity": "sha512-B+L5iIa9mgcjLbliir2th36yEwPftrzteHYujzsx3dFP/31GCHcIeS8f5MGd80odLOjaOvSpU3EEAmRQptkxLQ==", + "license": "ISC", + "dependencies": { + "@npmcli/fs": "^3.1.0", + "fs-minipass": "^3.0.0", + "glob": "^10.2.2", + "lru-cache": "^10.0.1", + "minipass": "^7.0.3", + "minipass-collect": "^2.0.1", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "p-map": "^4.0.0", + "ssri": "^10.0.0", + "tar": "^6.1.11", + "unique-filename": "^3.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/cacheable-lookup": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz", + "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==", + "license": "MIT", + "engines": { + "node": ">=10.6.0" + } + }, + "node_modules/cacheable-request": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz", + "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==", + "license": "MIT", + "dependencies": { + "clone-response": "^1.0.2", + "get-stream": "^5.1.0", + "http-cache-semantics": "^4.0.0", + "keyv": "^4.0.0", + "lowercase-keys": "^2.0.0", + "normalize-url": "^6.0.1", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cacheable-request/node_modules/get-stream": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz", + "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==", + "license": "MIT", + "dependencies": { + "pump": "^3.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/chownr": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", + "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/cjs-module-lexer": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz", + "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==", + "license": "MIT" + }, + "node_modules/clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/cliui/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/cliui/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/cliui/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cliui/node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/clone-response": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz", + "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==", + "license": "MIT", + "dependencies": { + "mimic-response": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cmd-shim": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/cmd-shim/-/cmd-shim-6.0.3.tgz", + "integrity": "sha512-FMabTRlc5t5zjdenF6mS0MBeFZm0XqHqeOkcskKFb/LYCcRQ5fVgLOHVc4Lq9CqABd9zhjwPjMBCJvMCziSVtA==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/common-ancestor-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/common-ancestor-path/-/common-ancestor-path-1.0.1.tgz", + "integrity": "sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==", + "license": "ISC" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/cross-spawn/node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" + }, + "node_modules/cross-spawn/node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/debug": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz", + "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", + "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "license": "MIT", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", + "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz", + "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "license": "MIT" + }, + "node_modules/encoding": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", + "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", + "license": "MIT", + "optional": true, + "dependencies": { + "iconv-lite": "^0.6.2" + } + }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "license": "MIT", + "dependencies": { + "once": "^1.4.0" + } + }, + "node_modules/env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/err-code": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", + "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==", + "license": "MIT" + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/exponential-backoff": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.2.tgz", + "integrity": "sha512-8QxYTVXUkuy7fIIoitQkPwGonB8F3Zj8eEO8Sqg9Zv/bkI7RJAzowee4gr81Hak/dUTpA2Z7VfQgoijjPNlUZA==", + "license": "Apache-2.0" + }, + "node_modules/fdir": { + "version": "6.4.6", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.6.tgz", + "integrity": "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==", + "license": "MIT", + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/find-up": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-6.3.0.tgz", + "integrity": "sha512-v2ZsoEuVHYy8ZIlYqwPe/39Cy+cFDzp4dXPaxNvkEuouymu+2Jbz0PxpKarJHYJTmv2HWT3O382qY8l4jMWthw==", + "license": "MIT", + "dependencies": { + "locate-path": "^7.1.0", + "path-exists": "^5.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/fs-minipass": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz", + "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==", + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/glob": { + "version": "10.4.5", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", + "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", + "license": "ISC", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/google-protobuf": { + "version": "3.21.4", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.21.4.tgz", + "integrity": "sha512-MnG7N936zcKTco4Jd2PX2U96Kf9PxygAPKBug+74LHzmHXmceN16MmRcdgZv+DGef/S9YvQAfRsNCn4cjf9yyQ==", + "license": "(BSD-3-Clause AND Apache-2.0)" + }, + "node_modules/got": { + "version": "11.8.6", + "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz", + "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==", + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^4.0.0", + "@szmarczak/http-timer": "^4.0.5", + "@types/cacheable-request": "^6.0.1", + "@types/responselike": "^1.0.0", + "cacheable-lookup": "^5.0.3", + "cacheable-request": "^7.0.2", + "decompress-response": "^6.0.0", + "http2-wrapper": "^1.0.0-beta.5.2", + "lowercase-keys": "^2.0.0", + "p-cancelable": "^2.0.0", + "responselike": "^2.0.0" + }, + "engines": { + "node": ">=10.19.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hosted-git-info": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-7.0.2.tgz", + "integrity": "sha512-puUZAUKT5m8Zzvs72XWy3HtvVbTWljRE66cP60bxJzAqf2DgICo7lYTY2IHUmLnNpjYvw5bvmoHvPc0QO2a62w==", + "license": "ISC", + "dependencies": { + "lru-cache": "^10.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/http-cache-semantics": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz", + "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==", + "license": "BSD-2-Clause" + }, + "node_modules/http-proxy-agent": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz", + "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==", + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/http2-wrapper": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz", + "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==", + "license": "MIT", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.0.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, + "node_modules/https-proxy-agent": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", + "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "license": "Apache-2.0", + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "license": "MIT", + "optional": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ignore-walk": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-6.0.5.tgz", + "integrity": "sha512-VuuG0wCnjhnylG1ABXT3dAuIpTNDs/G8jlpmwXY03fXoXy/8ZK8/T+hMzt8L4WnrLCJgdybqgPagnF/f97cg3A==", + "license": "ISC", + "dependencies": { + "minimatch": "^9.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/import-in-the-middle": { + "version": "1.14.2", + "resolved": "https://registry.npmjs.org/import-in-the-middle/-/import-in-the-middle-1.14.2.tgz", + "integrity": "sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw==", + "license": "Apache-2.0", + "dependencies": { + "acorn": "^8.14.0", + "acorn-import-attributes": "^1.9.5", + "cjs-module-lexer": "^1.2.2", + "module-details-from-path": "^1.0.3" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ini": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ini/-/ini-2.0.0.tgz", + "integrity": "sha512-7PnF4oN3CvZF23ADhA5wRaYEQpJ8qygSkbtTXWBeXWXmEVRXK+1ITciHWwHhsjv1TmW0MgacIv6hEi5pX5NQdA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/ip-address": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz", + "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==", + "license": "MIT", + "dependencies": { + "jsbn": "1.1.0", + "sprintf-js": "^1.1.3" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/ip-address/node_modules/sprintf-js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", + "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", + "license": "BSD-3-Clause" + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-lambda": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", + "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==", + "license": "MIT" + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isexe": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.1.tgz", + "integrity": "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==", + "license": "ISC", + "engines": { + "node": ">=16" + } + }, + "node_modules/jackspeak": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "license": "MIT", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsbn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz", + "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==", + "license": "MIT" + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "license": "MIT" + }, + "node_modules/json-parse-even-better-errors": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-3.0.2.tgz", + "integrity": "sha512-fi0NG4bPjCHunUJffmLd0gxssIgkNmArMvis4iNah6Owg1MCJjWhEcDLmsK6iGkJq3tHwbDkTlce70/tmXN4cQ==", + "license": "MIT", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/json-stringify-nice": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/json-stringify-nice/-/json-stringify-nice-1.1.4.tgz", + "integrity": "sha512-5Z5RFW63yxReJ7vANgW6eZFGWaQvnPE3WNmZoOJrSkGju2etKA2L5rrOa1sm877TVTFt57A80BH1bArcmlLfPw==", + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==", + "engines": [ + "node >= 0.2.0" + ], + "license": "MIT" + }, + "node_modules/just-diff": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/just-diff/-/just-diff-6.0.2.tgz", + "integrity": "sha512-S59eriX5u3/QhMNq3v/gm8Kd0w8OS6Tz2FS1NG4blv+z0MuQcBRJyFWjdovM0Rad4/P4aUPFtnkNjMjyMlMSYA==", + "license": "MIT" + }, + "node_modules/just-diff-apply": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/just-diff-apply/-/just-diff-apply-5.5.0.tgz", + "integrity": "sha512-OYTthRfSh55WOItVqwpefPtNt2VdKsq5AnAK6apdtR6yCH8pr0CmSr710J0Mf+WdQy7K/OzMy7K2MgAfdQURDw==", + "license": "MIT" + }, + "node_modules/keyv": { + "version": "4.5.4", + "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/locate-path": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz", + "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==", + "license": "MIT", + "dependencies": { + "p-locate": "^6.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", + "license": "MIT" + }, + "node_modules/long": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz", + "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==", + "license": "Apache-2.0" + }, + "node_modules/lowercase-keys": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz", + "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/lru-cache": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", + "license": "ISC" + }, + "node_modules/make-fetch-happen": { + "version": "13.0.1", + "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-13.0.1.tgz", + "integrity": "sha512-cKTUFc/rbKUd/9meOvgrpJ2WrNzymt6jfRDdwg5UCnVzv9dTpEj9JS5m3wtziXVCjluIXyL8pcaukYqezIzZQA==", + "license": "ISC", + "dependencies": { + "@npmcli/agent": "^2.0.0", + "cacache": "^18.0.0", + "http-cache-semantics": "^4.1.1", + "is-lambda": "^1.0.1", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minipass-flush": "^1.0.5", + "minipass-pipeline": "^1.2.4", + "negotiator": "^0.6.3", + "proc-log": "^4.2.0", + "promise-retry": "^2.0.1", + "ssri": "^10.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "license": "MIT" + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/minipass-collect": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz", + "integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==", + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/minipass-fetch": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-3.0.5.tgz", + "integrity": "sha512-2N8elDQAtSnFV0Dk7gt15KHsS0Fyz6CbYZ360h0WTYV1Ty46li3rAXVOQj1THMNLdmrD9Vt5pBPtWtVkpwGBqg==", + "license": "MIT", + "dependencies": { + "minipass": "^7.0.3", + "minipass-sized": "^1.0.3", + "minizlib": "^2.1.2" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + }, + "optionalDependencies": { + "encoding": "^0.1.13" + } + }, + "node_modules/minipass-flush": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", + "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minipass-flush/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-pipeline": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", + "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-pipeline/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-sized": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz", + "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==", + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minipass-sized/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/minizlib": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", + "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "license": "MIT", + "dependencies": { + "minipass": "^3.0.0", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/minizlib/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "license": "MIT", + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/module-details-from-path": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/module-details-from-path/-/module-details-from-path-1.0.4.tgz", + "integrity": "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w==", + "license": "MIT" + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz", + "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/node-gyp": { + "version": "10.3.1", + "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-10.3.1.tgz", + "integrity": "sha512-Pp3nFHBThHzVtNY7U6JfPjvT/DTE8+o/4xKsLQtBoU+j2HLsGlhcfzflAoUreaJbNmYnX+LlLi0qjV8kpyO6xQ==", + "license": "MIT", + "dependencies": { + "env-paths": "^2.2.0", + "exponential-backoff": "^3.1.1", + "glob": "^10.3.10", + "graceful-fs": "^4.2.6", + "make-fetch-happen": "^13.0.0", + "nopt": "^7.0.0", + "proc-log": "^4.1.0", + "semver": "^7.3.5", + "tar": "^6.2.1", + "which": "^4.0.0" + }, + "bin": { + "node-gyp": "bin/node-gyp.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/nopt": { + "version": "7.2.1", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-7.2.1.tgz", + "integrity": "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==", + "license": "ISC", + "dependencies": { + "abbrev": "^2.0.0" + }, + "bin": { + "nopt": "bin/nopt.js" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/normalize-package-data": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-6.0.2.tgz", + "integrity": "sha512-V6gygoYb/5EmNI+MEGrWkC+e6+Rr7mTmfHrxDbLzxQogBkgzo76rkok0Am6thgSF7Mv2nLOajAJj5vDJZEFn7g==", + "license": "BSD-2-Clause", + "dependencies": { + "hosted-git-info": "^7.0.0", + "semver": "^7.3.5", + "validate-npm-package-license": "^3.0.4" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-bundled": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-3.0.1.tgz", + "integrity": "sha512-+AvaheE/ww1JEwRHOrn4WHNzOxGtVp+adrg2AeZS/7KuxGUYFuBta98wYpfHBbJp6Tg6j1NKSEVHNcfZzJHQwQ==", + "license": "ISC", + "dependencies": { + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-install-checks": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/npm-install-checks/-/npm-install-checks-6.3.0.tgz", + "integrity": "sha512-W29RiK/xtpCGqn6f3ixfRYGk+zRyr+Ew9F2E20BfXxT5/euLdA/Nm7fO7OeTGuAmTs30cpgInyJ0cYe708YTZw==", + "license": "BSD-2-Clause", + "dependencies": { + "semver": "^7.1.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-normalize-package-bin": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-3.0.1.tgz", + "integrity": "sha512-dMxCf+zZ+3zeQZXKxmyuCKlIDPGuv8EF940xbkC4kQVDTtqoh6rJFO+JTKSA6/Rwi0getWmtuy4Itup0AMcaDQ==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-package-arg": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/npm-package-arg/-/npm-package-arg-11.0.3.tgz", + "integrity": "sha512-sHGJy8sOC1YraBywpzQlIKBE4pBbGbiF95U6Auspzyem956E0+FtDtsx1ZxlOJkQCZ1AFXAY/yuvtFYrOxF+Bw==", + "license": "ISC", + "dependencies": { + "hosted-git-info": "^7.0.0", + "proc-log": "^4.0.0", + "semver": "^7.3.5", + "validate-npm-package-name": "^5.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm-packlist": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-8.0.2.tgz", + "integrity": "sha512-shYrPFIS/JLP4oQmAwDyk5HcyysKW8/JLTEA32S0Z5TzvpaeeX2yMFfoK1fjEBnCBvVyIB/Jj/GBFdm0wsgzbA==", + "license": "ISC", + "dependencies": { + "ignore-walk": "^6.0.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/npm-pick-manifest": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/npm-pick-manifest/-/npm-pick-manifest-9.1.0.tgz", + "integrity": "sha512-nkc+3pIIhqHVQr085X9d2JzPzLyjzQS96zbruppqC9aZRm/x8xx6xhI98gHtsfELP2bE+loHq8ZaHFHhe+NauA==", + "license": "ISC", + "dependencies": { + "npm-install-checks": "^6.0.0", + "npm-normalize-package-bin": "^3.0.0", + "npm-package-arg": "^11.0.0", + "semver": "^7.3.5" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm-registry-fetch": { + "version": "17.1.0", + "resolved": "https://registry.npmjs.org/npm-registry-fetch/-/npm-registry-fetch-17.1.0.tgz", + "integrity": "sha512-5+bKQRH0J1xG1uZ1zMNvxW0VEyoNWgJpY9UDuluPFLKDfJ9u2JmmjmTJV1srBGQOROfdBMiVvnH2Zvpbm+xkVA==", + "license": "ISC", + "dependencies": { + "@npmcli/redact": "^2.0.0", + "jsonparse": "^1.3.1", + "make-fetch-happen": "^13.0.0", + "minipass": "^7.0.2", + "minipass-fetch": "^3.0.0", + "minizlib": "^2.1.2", + "npm-package-arg": "^11.0.0", + "proc-log": "^4.0.0" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "license": "MIT", + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-cancelable": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz", + "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/p-limit": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz", + "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==", + "license": "MIT", + "dependencies": { + "yocto-queue": "^1.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz", + "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==", + "license": "MIT", + "dependencies": { + "p-limit": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "license": "MIT", + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "license": "BlueOak-1.0.0" + }, + "node_modules/pacote": { + "version": "18.0.6", + "resolved": "https://registry.npmjs.org/pacote/-/pacote-18.0.6.tgz", + "integrity": "sha512-+eK3G27SMwsB8kLIuj4h1FUhHtwiEUo21Tw8wNjmvdlpOEr613edv+8FUsTj/4F/VN5ywGE19X18N7CC2EJk6A==", + "license": "ISC", + "dependencies": { + "@npmcli/git": "^5.0.0", + "@npmcli/installed-package-contents": "^2.0.1", + "@npmcli/package-json": "^5.1.0", + "@npmcli/promise-spawn": "^7.0.0", + "@npmcli/run-script": "^8.0.0", + "cacache": "^18.0.0", + "fs-minipass": "^3.0.0", + "minipass": "^7.0.2", + "npm-package-arg": "^11.0.0", + "npm-packlist": "^8.0.0", + "npm-pick-manifest": "^9.0.0", + "npm-registry-fetch": "^17.0.0", + "proc-log": "^4.0.0", + "promise-retry": "^2.0.1", + "sigstore": "^2.2.0", + "ssri": "^10.0.0", + "tar": "^6.1.11" + }, + "bin": { + "pacote": "bin/index.js" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/parse-conflict-json": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/parse-conflict-json/-/parse-conflict-json-3.0.1.tgz", + "integrity": "sha512-01TvEktc68vwbJOtWZluyWeVGWjP+bZwXtPDMQVbBKzbJ/vZBif0L69KH1+cHv1SZ6e0FKLvjyHe8mqsIqYOmw==", + "license": "ISC", + "dependencies": { + "json-parse-even-better-errors": "^3.0.0", + "just-diff": "^6.0.0", + "just-diff-apply": "^5.2.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/path-exists": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz", + "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/picomatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-3.0.1.tgz", + "integrity": "sha512-I3EurrIQMlRc9IaAZnqRR044Phh2DXY+55o7uJ0V+hYZAcQYSuFWsc9q5PvyDHUSCe1Qxn/iBz+78s86zWnGag==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pkg-dir": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-7.0.0.tgz", + "integrity": "sha512-Ie9z/WINcxxLp27BKOCHGde4ITq9UklYKDzVo1nhk5sqGEXU3FpkwP5GM2voTGJkGd9B3Otl+Q4uwSOeSUtOBA==", + "license": "MIT", + "dependencies": { + "find-up": "^6.3.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/proc-log": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-4.2.0.tgz", + "integrity": "sha512-g8+OnU/L2v+wyiVK+D5fA34J7EH8jZ8DDlvwhRCMxmMj7UCBvxiO1mGeN+36JXIKF4zevU4kRBd8lVgG9vLelA==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/proggy": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/proggy/-/proggy-2.0.0.tgz", + "integrity": "sha512-69agxLtnI8xBs9gUGqEnK26UfiexpHy+KUpBQWabiytQjnn5wFY8rklAi7GRfABIuPNnQ/ik48+LGLkYYJcy4A==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/promise-all-reject-late": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-all-reject-late/-/promise-all-reject-late-1.0.1.tgz", + "integrity": "sha512-vuf0Lf0lOxyQREH7GDIOUMLS7kz+gs8i6B+Yi8dC68a2sychGrHTJYghMBD6k7eUcH0H5P73EckCA48xijWqXw==", + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/promise-call-limit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/promise-call-limit/-/promise-call-limit-3.0.2.tgz", + "integrity": "sha512-mRPQO2T1QQVw11E7+UdCJu7S61eJVWknzml9sC1heAdj1jxl0fWMBypIt9ZOcLFf8FkG995ZD7RnVk7HH72fZw==", + "license": "ISC", + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/promise-inflight": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", + "integrity": "sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==", + "license": "ISC" + }, + "node_modules/promise-retry": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", + "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", + "license": "MIT", + "dependencies": { + "err-code": "^2.0.2", + "retry": "^0.12.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/protobufjs": { + "version": "7.5.3", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.3.tgz", + "integrity": "sha512-sildjKwVqOI2kmFDiXQ6aEB0fjYTafpEvIBs8tOR8qI4spuL9OPROLVu2qZqi/xgCfsHIwVqlaF8JBjWFHnKbw==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/pump": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.3.tgz", + "integrity": "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==", + "license": "MIT", + "dependencies": { + "end-of-stream": "^1.1.0", + "once": "^1.3.1" + } + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", + "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/read-cmd-shim": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/read-cmd-shim/-/read-cmd-shim-4.0.0.tgz", + "integrity": "sha512-yILWifhaSEEytfXI76kB9xEEiG1AiozaCJZ83A87ytjRiN+jVibXjedjCRNjoZviinhG+4UkalO3mWTd8u5O0Q==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/read-package-json-fast": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/read-package-json-fast/-/read-package-json-fast-3.0.2.tgz", + "integrity": "sha512-0J+Msgym3vrLOUB3hzQCuZHII0xkNGCtz/HJH9xZshwv9DbDwkw1KaE3gx/e2J5rpEY5rtOy6cyhKOPrkP7FZw==", + "license": "ISC", + "dependencies": { + "json-parse-even-better-errors": "^3.0.0", + "npm-normalize-package-bin": "^3.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-in-the-middle": { + "version": "7.5.2", + "resolved": "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-7.5.2.tgz", + "integrity": "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ==", + "license": "MIT", + "dependencies": { + "debug": "^4.3.5", + "module-details-from-path": "^1.0.3", + "resolve": "^1.22.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/resolve": { + "version": "1.22.10", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-alpn": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz", + "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==", + "license": "MIT" + }, + "node_modules/responselike": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz", + "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==", + "license": "MIT", + "dependencies": { + "lowercase-keys": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT", + "optional": true + }, + "node_modules/semver": { + "version": "7.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", + "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/shimmer": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/shimmer/-/shimmer-1.2.1.tgz", + "integrity": "sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw==", + "license": "BSD-2-Clause" + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "license": "ISC" + }, + "node_modules/sigstore": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/sigstore/-/sigstore-2.3.1.tgz", + "integrity": "sha512-8G+/XDU8wNsJOQS5ysDVO0Etg9/2uA5gR9l4ZwijjlwxBcrU6RPfwi2+jJmbP+Ap1Hlp/nVAaEO4Fj22/SL2gQ==", + "license": "Apache-2.0", + "dependencies": { + "@sigstore/bundle": "^2.3.2", + "@sigstore/core": "^1.0.0", + "@sigstore/protobuf-specs": "^0.3.2", + "@sigstore/sign": "^2.3.2", + "@sigstore/tuf": "^2.3.4", + "@sigstore/verify": "^1.2.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/smart-buffer": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", + "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "license": "MIT", + "engines": { + "node": ">= 6.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks": { + "version": "2.8.5", + "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.5.tgz", + "integrity": "sha512-iF+tNDQla22geJdTyJB1wM/qrX9DMRwWrciEPwWLPRWAUEM8sQiyxgckLxWT1f7+9VabJS0jTGGr4QgBuvi6Ww==", + "license": "MIT", + "dependencies": { + "ip-address": "^9.0.5", + "smart-buffer": "^4.2.0" + }, + "engines": { + "node": ">= 10.0.0", + "npm": ">= 3.0.0" + } + }, + "node_modules/socks-proxy-agent": { + "version": "8.0.5", + "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz", + "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==", + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.2", + "debug": "^4.3.4", + "socks": "^2.8.3" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/spdx-correct": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz", + "integrity": "sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==", + "license": "Apache-2.0", + "dependencies": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-exceptions": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.5.0.tgz", + "integrity": "sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==", + "license": "CC-BY-3.0" + }, + "node_modules/spdx-expression-parse": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", + "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", + "license": "MIT", + "dependencies": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "node_modules/spdx-license-ids": { + "version": "3.0.21", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.21.tgz", + "integrity": "sha512-Bvg/8F5XephndSK3JffaRqdT+gyhfqIPwDHpX80tJrF8QQRYMo8sNMeaZ2Dp5+jhwKnUmIOyFFQfHRkjJm5nXg==", + "license": "CC0-1.0" + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "license": "BSD-3-Clause" + }, + "node_modules/ssri": { + "version": "10.0.6", + "resolved": "https://registry.npmjs.org/ssri/-/ssri-10.0.6.tgz", + "integrity": "sha512-MGrFH9Z4NP9Iyhqn16sDtBpRRNJ0Y2hNa6D65h736fVSaPCHr4DM4sWUNvVaSuC+0OBGhwsrydQwmgfg5LncqQ==", + "license": "ISC", + "dependencies": { + "minipass": "^7.0.3" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/string-width-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tar": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", + "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", + "license": "ISC", + "dependencies": { + "chownr": "^2.0.0", + "fs-minipass": "^2.0.0", + "minipass": "^5.0.0", + "minizlib": "^2.1.1", + "mkdirp": "^1.0.3", + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/tar/node_modules/fs-minipass": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", + "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "license": "ISC", + "dependencies": { + "minipass": "^3.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/tar/node_modules/fs-minipass/node_modules/minipass": { + "version": "3.3.6", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", + "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tar/node_modules/minipass": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", + "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", + "license": "ISC", + "engines": { + "node": ">=8" + } + }, + "node_modules/tmp": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz", + "integrity": "sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==", + "license": "MIT", + "engines": { + "node": ">=14.14" + } + }, + "node_modules/treeverse": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/treeverse/-/treeverse-3.0.0.tgz", + "integrity": "sha512-gcANaAnd2QDZFmHFEOF4k7uc1J/6a6z3DJMd/QwEyxLoKGiptJRwid582r7QIsFlFMIZ3SnxfS52S4hm2DHkuQ==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/tuf-js": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tuf-js/-/tuf-js-2.2.1.tgz", + "integrity": "sha512-GwIJau9XaA8nLVbUXsN3IlFi7WmQ48gBUrl3FTkkL/XLu/POhBzfmX9hd33FNMX1qAsfl6ozO1iMmW9NC8YniA==", + "license": "MIT", + "dependencies": { + "@tufjs/models": "2.0.1", + "debug": "^4.3.4", + "make-fetch-happen": "^13.0.1" + }, + "engines": { + "node": "^16.14.0 || >=18.0.0" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "devOptional": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "license": "MIT" + }, + "node_modules/unique-filename": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-3.0.0.tgz", + "integrity": "sha512-afXhuC55wkAmZ0P18QsVE6kp8JaxrEokN2HGIoIVv2ijHQd419H0+6EigAFcIzXeMIkcIkNBpB3L/DXB3cTS/g==", + "license": "ISC", + "dependencies": { + "unique-slug": "^4.0.0" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/unique-slug": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-4.0.0.tgz", + "integrity": "sha512-WrcA6AyEfqDX5bWige/4NQfPZMtASNVxdmWR76WESYQVAACSgWcR6e9i0mofqqBxYFtL4oAxPIptY73/0YE1DQ==", + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "license": "MIT", + "engines": { + "node": ">=4", + "yarn": "*" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" + }, + "node_modules/validate-npm-package-license": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", + "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", + "license": "Apache-2.0", + "dependencies": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "node_modules/validate-npm-package-name": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/validate-npm-package-name/-/validate-npm-package-name-5.0.1.tgz", + "integrity": "sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/walk-up-path": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/walk-up-path/-/walk-up-path-3.0.1.tgz", + "integrity": "sha512-9YlCL/ynK3CTlrSRrDxZvUauLzAswPCrsaCgilqFevUYpeEW0/3ScEjaa3kbW/T0ghhkEr7mv+fpjqn1Y1YuTA==", + "license": "ISC" + }, + "node_modules/which": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/which/-/which-4.0.0.tgz", + "integrity": "sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==", + "license": "ISC", + "dependencies": { + "isexe": "^3.1.1" + }, + "bin": { + "node-which": "bin/which.js" + }, + "engines": { + "node": "^16.13.0 || >=18.0.0" + } + }, + "node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/wrap-ansi-cjs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/write-file-atomic": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-5.0.1.tgz", + "integrity": "sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==", + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/write-file-atomic/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "license": "ISC" + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "license": "MIT", + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs/node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/yargs/node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yargs/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/yocto-queue": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.1.tgz", + "integrity": "sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg==", + "license": "MIT", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/examples/ts/package.json b/examples/ts/package.json new file mode 100644 index 0000000..2e1ca3a --- /dev/null +++ b/examples/ts/package.json @@ -0,0 +1,12 @@ +{ + "name": "example-ts", + "main": "index.ts", + "devDependencies": { + "@types/node": "^18", + "typescript": "^5.0.0" + }, + "dependencies": { + "@pulumi/pulumi": "^3.113.0", + "@stackitcloud/pulumi-stackit": "^0.1.2" + } +} diff --git a/examples/ts/tsconfig.json b/examples/ts/tsconfig.json new file mode 100644 index 0000000..f960d51 --- /dev/null +++ b/examples/ts/tsconfig.json @@ -0,0 +1,18 @@ +{ + "compilerOptions": { + "strict": true, + "outDir": "bin", + "target": "es2020", + "module": "commonjs", + "moduleResolution": "node", + "sourceMap": true, + "experimentalDecorators": true, + "pretty": true, + "noFallthroughCasesInSwitch": true, + "noImplicitReturns": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.ts" + ] +} diff --git a/provider/cmd/pulumi-resource-stackit/.gitignore b/provider/cmd/pulumi-resource-stackit/.gitignore new file mode 100644 index 0000000..eaadaff --- /dev/null +++ b/provider/cmd/pulumi-resource-stackit/.gitignore @@ -0,0 +1 @@ +schema.go diff --git a/provider/cmd/pulumi-resource-stackit/Pulumi.yaml b/provider/cmd/pulumi-resource-stackit/Pulumi.yaml new file mode 100644 index 0000000..e69de29 diff --git a/provider/cmd/pulumi-resource-stackit/bridge-metadata.json b/provider/cmd/pulumi-resource-stackit/bridge-metadata.json new file mode 100644 index 0000000..ba563ca --- /dev/null +++ b/provider/cmd/pulumi-resource-stackit/bridge-metadata.json @@ -0,0 +1,1088 @@ +{ + "auto-aliasing": { + "resources": { + "stackit_affinity_group": { + "current": "stackit:index/affinityGroup:AffinityGroup", + "fields": { + "members": { + "maxItemsOne": false + } + } + }, + "stackit_authorization_organization_role_assignment": { + "current": "stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment" + }, + "stackit_authorization_project_role_assignment": { + "current": "stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment" + }, + "stackit_cdn_custom_domain": { + "current": "stackit:index/cdnCustomDomain:CdnCustomDomain", + "fields": { + "errors": { + "maxItemsOne": false + } + } + }, + "stackit_cdn_distribution": { + "current": "stackit:index/cdnDistribution:CdnDistribution", + "fields": { + "config": { + "fields": { + "regions": { + "maxItemsOne": false + } + } + }, + "domains": { + "maxItemsOne": false, + "elem": { + "fields": { + "errors": { + "maxItemsOne": false + } + } + } + }, + "errors": { + "maxItemsOne": false + } + } + }, + "stackit_dns_record_set": { + "current": "stackit:index/dnsRecordSet:DnsRecordSet", + "fields": { + "records": { + "maxItemsOne": false + } + } + }, + "stackit_dns_zone": { + "current": "stackit:index/dnsZone:DnsZone", + "fields": { + "primaries": { + "maxItemsOne": false + } + } + }, + "stackit_git": { + "current": "stackit:index/git:Git" + }, + "stackit_image": { + "current": "stackit:index/image:Image" + }, + "stackit_key_pair": { + "current": "stackit:index/keyPair:KeyPair" + }, + "stackit_loadbalancer": { + "current": "stackit:index/loadbalancer:Loadbalancer", + "fields": { + "listeners": { + "maxItemsOne": false, + "elem": { + "fields": { + "server_name_indicators": { + "maxItemsOne": false + } + } + } + }, + "networks": { + "maxItemsOne": false + }, + "options": { + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "target_pools": { + "maxItemsOne": false, + "elem": { + "fields": { + "targets": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_loadbalancer_observability_credential": { + "current": "stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential" + }, + "stackit_logme_credential": { + "current": "stackit:index/logmeCredential:LogmeCredential" + }, + "stackit_logme_instance": { + "current": "stackit:index/logmeInstance:LogmeInstance", + "fields": { + "parameters": { + "fields": { + "opensearch_tls_ciphers": { + "maxItemsOne": false + }, + "opensearch_tls_protocols": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_mariadb_credential": { + "current": "stackit:index/mariadbCredential:MariadbCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_mariadb_instance": { + "current": "stackit:index/mariadbInstance:MariadbInstance", + "fields": { + "parameters": { + "fields": { + "syslog": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_modelserving_token": { + "current": "stackit:index/modelservingToken:ModelservingToken" + }, + "stackit_mongodbflex_instance": { + "current": "stackit:index/mongodbflexInstance:MongodbflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_mongodbflex_user": { + "current": "stackit:index/mongodbflexUser:MongodbflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_network": { + "current": "stackit:index/network:Network", + "fields": { + "ipv4_nameservers": { + "maxItemsOne": false + }, + "ipv4_prefixes": { + "maxItemsOne": false + }, + "ipv6_nameservers": { + "maxItemsOne": false + }, + "ipv6_prefixes": { + "maxItemsOne": false + }, + "nameservers": { + "maxItemsOne": false + }, + "prefixes": { + "maxItemsOne": false + } + } + }, + "stackit_network_area": { + "current": "stackit:index/networkArea:NetworkArea", + "fields": { + "default_nameservers": { + "maxItemsOne": false + }, + "network_ranges": { + "maxItemsOne": false + } + } + }, + "stackit_network_area_route": { + "current": "stackit:index/networkAreaRoute:NetworkAreaRoute" + }, + "stackit_network_interface": { + "current": "stackit:index/networkInterface:NetworkInterface", + "fields": { + "allowed_addresses": { + "maxItemsOne": false + }, + "security_group_ids": { + "maxItemsOne": false + } + } + }, + "stackit_objectstorage_bucket": { + "current": "stackit:index/objectstorageBucket:ObjectstorageBucket" + }, + "stackit_objectstorage_credential": { + "current": "stackit:index/objectstorageCredential:ObjectstorageCredential" + }, + "stackit_objectstorage_credentials_group": { + "current": "stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup" + }, + "stackit_observability_alertgroup": { + "current": "stackit:index/observabilityAlertgroup:ObservabilityAlertgroup", + "fields": { + "rules": { + "maxItemsOne": false + } + } + }, + "stackit_observability_credential": { + "current": "stackit:index/observabilityCredential:ObservabilityCredential" + }, + "stackit_observability_instance": { + "current": "stackit:index/observabilityInstance:ObservabilityInstance", + "fields": { + "acl": { + "maxItemsOne": false + }, + "alert_config": { + "fields": { + "receivers": { + "maxItemsOne": false, + "elem": { + "fields": { + "email_configs": { + "maxItemsOne": false + }, + "opsgenie_configs": { + "maxItemsOne": false + }, + "webhooks_configs": { + "maxItemsOne": false + } + } + } + }, + "route": { + "fields": { + "group_by": { + "maxItemsOne": false + }, + "routes": { + "maxItemsOne": false, + "elem": { + "fields": { + "group_by": { + "maxItemsOne": false + } + } + } + } + } + } + } + } + } + }, + "stackit_observability_logalertgroup": { + "current": "stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup", + "fields": { + "rules": { + "maxItemsOne": false + } + } + }, + "stackit_observability_scrapeconfig": { + "current": "stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig", + "fields": { + "targets": { + "maxItemsOne": false, + "elem": { + "fields": { + "urls": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_opensearch_credential": { + "current": "stackit:index/opensearchCredential:OpensearchCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_opensearch_instance": { + "current": "stackit:index/opensearchInstance:OpensearchInstance", + "fields": { + "parameters": { + "fields": { + "plugins": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_postgresflex_database": { + "current": "stackit:index/postgresflexDatabase:PostgresflexDatabase" + }, + "stackit_postgresflex_instance": { + "current": "stackit:index/postgresflexInstance:PostgresflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_postgresflex_user": { + "current": "stackit:index/postgresflexUser:PostgresflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_public_ip": { + "current": "stackit:index/publicIp:PublicIp" + }, + "stackit_public_ip_associate": { + "current": "stackit:index/publicIpAssociate:PublicIpAssociate" + }, + "stackit_rabbitmq_credential": { + "current": "stackit:index/rabbitmqCredential:RabbitmqCredential", + "fields": { + "hosts": { + "maxItemsOne": false + }, + "http_api_uris": { + "maxItemsOne": false + }, + "uris": { + "maxItemsOne": false + } + } + }, + "stackit_rabbitmq_instance": { + "current": "stackit:index/rabbitmqInstance:RabbitmqInstance", + "fields": { + "parameters": { + "fields": { + "plugins": { + "maxItemsOne": false + }, + "roles": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_redis_credential": { + "current": "stackit:index/redisCredential:RedisCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_redis_instance": { + "current": "stackit:index/redisInstance:RedisInstance", + "fields": { + "parameters": { + "fields": { + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_resourcemanager_project": { + "current": "stackit:index/resourcemanagerProject:ResourcemanagerProject" + }, + "stackit_secretsmanager_instance": { + "current": "stackit:index/secretsmanagerInstance:SecretsmanagerInstance", + "fields": { + "acls": { + "maxItemsOne": false + } + } + }, + "stackit_secretsmanager_user": { + "current": "stackit:index/secretsmanagerUser:SecretsmanagerUser" + }, + "stackit_security_group": { + "current": "stackit:index/securityGroup:SecurityGroup" + }, + "stackit_security_group_rule": { + "current": "stackit:index/securityGroupRule:SecurityGroupRule" + }, + "stackit_server": { + "current": "stackit:index/server:Server", + "fields": { + "network_interfaces": { + "maxItemsOne": false + } + } + }, + "stackit_server_backup_schedule": { + "current": "stackit:index/serverBackupSchedule:ServerBackupSchedule", + "fields": { + "backup_properties": { + "fields": { + "volume_ids": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_server_network_interface_attach": { + "current": "stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach" + }, + "stackit_server_service_account_attach": { + "current": "stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach" + }, + "stackit_server_update_schedule": { + "current": "stackit:index/serverUpdateSchedule:ServerUpdateSchedule" + }, + "stackit_server_volume_attach": { + "current": "stackit:index/serverVolumeAttach:ServerVolumeAttach" + }, + "stackit_service_account": { + "current": "stackit:index/serviceAccount:ServiceAccount" + }, + "stackit_service_account_access_token": { + "current": "stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken" + }, + "stackit_service_account_key": { + "current": "stackit:index/serviceAccountKey:ServiceAccountKey" + }, + "stackit_ske_cluster": { + "current": "stackit:index/skeCluster:SkeCluster", + "fields": { + "egress_address_ranges": { + "maxItemsOne": false + }, + "extensions": { + "fields": { + "acl": { + "fields": { + "allowed_cidrs": { + "maxItemsOne": false + } + } + }, + "dns": { + "fields": { + "zones": { + "maxItemsOne": false + } + } + } + } + }, + "hibernations": { + "maxItemsOne": false + }, + "node_pools": { + "maxItemsOne": false, + "elem": { + "fields": { + "availability_zones": { + "maxItemsOne": false + }, + "taints": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_ske_kubeconfig": { + "current": "stackit:index/skeKubeconfig:SkeKubeconfig" + }, + "stackit_sqlserverflex_instance": { + "current": "stackit:index/sqlserverflexInstance:SqlserverflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_sqlserverflex_user": { + "current": "stackit:index/sqlserverflexUser:SqlserverflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_volume": { + "current": "stackit:index/volume:Volume" + } + }, + "datasources": { + "stackit_affinity_group": { + "current": "stackit:index/getAffinityGroup:getAffinityGroup", + "fields": { + "members": { + "maxItemsOne": false + } + } + }, + "stackit_cdn_custom_domain": { + "current": "stackit:index/getCdnCustomDomain:getCdnCustomDomain", + "fields": { + "errors": { + "maxItemsOne": false + } + } + }, + "stackit_cdn_distribution": { + "current": "stackit:index/getCdnDistribution:getCdnDistribution", + "fields": { + "config": { + "fields": { + "regions": { + "maxItemsOne": false + } + } + }, + "domains": { + "maxItemsOne": false, + "elem": { + "fields": { + "errors": { + "maxItemsOne": false + } + } + } + }, + "errors": { + "maxItemsOne": false + } + } + }, + "stackit_dns_record_set": { + "current": "stackit:index/getDnsRecordSet:getDnsRecordSet", + "fields": { + "records": { + "maxItemsOne": false + } + } + }, + "stackit_dns_zone": { + "current": "stackit:index/getDnsZone:getDnsZone", + "fields": { + "primaries": { + "maxItemsOne": false + } + } + }, + "stackit_git": { + "current": "stackit:index/getGit:getGit" + }, + "stackit_image": { + "current": "stackit:index/getImage:getImage" + }, + "stackit_key_pair": { + "current": "stackit:index/getKeyPair:getKeyPair" + }, + "stackit_loadbalancer": { + "current": "stackit:index/getLoadbalancer:getLoadbalancer", + "fields": { + "listeners": { + "maxItemsOne": false, + "elem": { + "fields": { + "server_name_indicators": { + "maxItemsOne": false + } + } + } + }, + "networks": { + "maxItemsOne": false + }, + "options": { + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "target_pools": { + "maxItemsOne": false, + "elem": { + "fields": { + "targets": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_logme_credential": { + "current": "stackit:index/getLogmeCredential:getLogmeCredential" + }, + "stackit_logme_instance": { + "current": "stackit:index/getLogmeInstance:getLogmeInstance", + "fields": { + "parameters": { + "fields": { + "opensearch_tls_ciphers": { + "maxItemsOne": false + }, + "opensearch_tls_protocols": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_mariadb_credential": { + "current": "stackit:index/getMariadbCredential:getMariadbCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_mariadb_instance": { + "current": "stackit:index/getMariadbInstance:getMariadbInstance", + "fields": { + "parameters": { + "fields": { + "syslog": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_mongodbflex_instance": { + "current": "stackit:index/getMongodbflexInstance:getMongodbflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_mongodbflex_user": { + "current": "stackit:index/getMongodbflexUser:getMongodbflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_network": { + "current": "stackit:index/getNetwork:getNetwork", + "fields": { + "ipv4_nameservers": { + "maxItemsOne": false + }, + "ipv4_prefixes": { + "maxItemsOne": false + }, + "ipv6_nameservers": { + "maxItemsOne": false + }, + "ipv6_prefixes": { + "maxItemsOne": false + }, + "nameservers": { + "maxItemsOne": false + }, + "prefixes": { + "maxItemsOne": false + } + } + }, + "stackit_network_area": { + "current": "stackit:index/getNetworkArea:getNetworkArea", + "fields": { + "default_nameservers": { + "maxItemsOne": false + }, + "network_ranges": { + "maxItemsOne": false + } + } + }, + "stackit_network_area_route": { + "current": "stackit:index/getNetworkAreaRoute:getNetworkAreaRoute" + }, + "stackit_network_interface": { + "current": "stackit:index/getNetworkInterface:getNetworkInterface", + "fields": { + "allowed_addresses": { + "maxItemsOne": false + }, + "security_group_ids": { + "maxItemsOne": false + } + } + }, + "stackit_objectstorage_bucket": { + "current": "stackit:index/getObjectstorageBucket:getObjectstorageBucket" + }, + "stackit_objectstorage_credential": { + "current": "stackit:index/getObjectstorageCredential:getObjectstorageCredential" + }, + "stackit_objectstorage_credentials_group": { + "current": "stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup" + }, + "stackit_observability_alertgroup": { + "current": "stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", + "fields": { + "rules": { + "maxItemsOne": false + } + } + }, + "stackit_observability_instance": { + "current": "stackit:index/getObservabilityInstance:getObservabilityInstance", + "fields": { + "acl": { + "maxItemsOne": false + }, + "alert_config": { + "fields": { + "receivers": { + "maxItemsOne": false, + "elem": { + "fields": { + "email_configs": { + "maxItemsOne": false + }, + "opsgenie_configs": { + "maxItemsOne": false + }, + "webhooks_configs": { + "maxItemsOne": false + } + } + } + }, + "route": { + "fields": { + "group_by": { + "maxItemsOne": false + }, + "routes": { + "maxItemsOne": false, + "elem": { + "fields": { + "group_by": { + "maxItemsOne": false + } + } + } + } + } + } + } + } + } + }, + "stackit_observability_logalertgroup": { + "current": "stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", + "fields": { + "rules": { + "maxItemsOne": false + } + } + }, + "stackit_observability_scrapeconfig": { + "current": "stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", + "fields": { + "targets": { + "maxItemsOne": false, + "elem": { + "fields": { + "urls": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_opensearch_credential": { + "current": "stackit:index/getOpensearchCredential:getOpensearchCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_opensearch_instance": { + "current": "stackit:index/getOpensearchInstance:getOpensearchInstance", + "fields": { + "parameters": { + "fields": { + "plugins": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_postgresflex_database": { + "current": "stackit:index/getPostgresflexDatabase:getPostgresflexDatabase" + }, + "stackit_postgresflex_instance": { + "current": "stackit:index/getPostgresflexInstance:getPostgresflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_postgresflex_user": { + "current": "stackit:index/getPostgresflexUser:getPostgresflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_public_ip": { + "current": "stackit:index/getPublicIp:getPublicIp" + }, + "stackit_public_ip_ranges": { + "current": "stackit:index/getPublicIpRanges:getPublicIpRanges", + "fields": { + "public_ip_ranges": { + "maxItemsOne": false + } + } + }, + "stackit_rabbitmq_credential": { + "current": "stackit:index/getRabbitmqCredential:getRabbitmqCredential", + "fields": { + "hosts": { + "maxItemsOne": false + }, + "http_api_uris": { + "maxItemsOne": false + }, + "uris": { + "maxItemsOne": false + } + } + }, + "stackit_rabbitmq_instance": { + "current": "stackit:index/getRabbitmqInstance:getRabbitmqInstance", + "fields": { + "parameters": { + "fields": { + "plugins": { + "maxItemsOne": false + }, + "roles": { + "maxItemsOne": false + }, + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_redis_credential": { + "current": "stackit:index/getRedisCredential:getRedisCredential", + "fields": { + "hosts": { + "maxItemsOne": false + } + } + }, + "stackit_redis_instance": { + "current": "stackit:index/getRedisInstance:getRedisInstance", + "fields": { + "parameters": { + "fields": { + "syslog": { + "maxItemsOne": false + }, + "tls_ciphers": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_resourcemanager_project": { + "current": "stackit:index/getResourcemanagerProject:getResourcemanagerProject" + }, + "stackit_secretsmanager_instance": { + "current": "stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", + "fields": { + "acls": { + "maxItemsOne": false + } + } + }, + "stackit_secretsmanager_user": { + "current": "stackit:index/getSecretsmanagerUser:getSecretsmanagerUser" + }, + "stackit_security_group": { + "current": "stackit:index/getSecurityGroup:getSecurityGroup" + }, + "stackit_security_group_rule": { + "current": "stackit:index/getSecurityGroupRule:getSecurityGroupRule" + }, + "stackit_server": { + "current": "stackit:index/getServer:getServer", + "fields": { + "network_interfaces": { + "maxItemsOne": false + } + } + }, + "stackit_server_backup_schedule": { + "current": "stackit:index/getServerBackupSchedule:getServerBackupSchedule", + "fields": { + "backup_properties": { + "fields": { + "volume_ids": { + "maxItemsOne": false + } + } + } + } + }, + "stackit_server_backup_schedules": { + "current": "stackit:index/getServerBackupSchedules:getServerBackupSchedules", + "fields": { + "items": { + "maxItemsOne": false, + "elem": { + "fields": { + "backup_properties": { + "fields": { + "volume_ids": { + "maxItemsOne": false + } + } + } + } + } + } + } + }, + "stackit_server_update_schedule": { + "current": "stackit:index/getServerUpdateSchedule:getServerUpdateSchedule" + }, + "stackit_server_update_schedules": { + "current": "stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", + "fields": { + "items": { + "maxItemsOne": false + } + } + }, + "stackit_service_account": { + "current": "stackit:index/getServiceAccount:getServiceAccount" + }, + "stackit_ske_cluster": { + "current": "stackit:index/getSkeCluster:getSkeCluster", + "fields": { + "egress_address_ranges": { + "maxItemsOne": false + }, + "extensions": { + "fields": { + "acl": { + "fields": { + "allowed_cidrs": { + "maxItemsOne": false + } + } + }, + "dns": { + "fields": { + "zones": { + "maxItemsOne": false + } + } + } + } + }, + "hibernations": { + "maxItemsOne": false + }, + "node_pools": { + "maxItemsOne": false, + "elem": { + "fields": { + "availability_zones": { + "maxItemsOne": false + }, + "taints": { + "maxItemsOne": false + } + } + } + } + } + }, + "stackit_sqlserverflex_instance": { + "current": "stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", + "fields": { + "acl": { + "maxItemsOne": false + } + } + }, + "stackit_sqlserverflex_user": { + "current": "stackit:index/getSqlserverflexUser:getSqlserverflexUser", + "fields": { + "roles": { + "maxItemsOne": false + } + } + }, + "stackit_volume": { + "current": "stackit:index/getVolume:getVolume" + } + } + }, + "auto-settings": {} +} \ No newline at end of file diff --git a/provider/cmd/pulumi-resource-stackit/generate.go b/provider/cmd/pulumi-resource-stackit/generate.go new file mode 100644 index 0000000..414389e --- /dev/null +++ b/provider/cmd/pulumi-resource-stackit/generate.go @@ -0,0 +1,63 @@ +// Copyright 2016-2020, Pulumi Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//go:build ignore + +package main + +import ( + "encoding/json" + "errors" + "io/fs" + "io/ioutil" + "log" + "os" + + "github.com/pulumi/pulumi/pkg/v3/codegen/schema" +) + +func main() { + version, found := os.LookupEnv("VERSION") + if !found { + log.Fatal("version not found") + } + + schemaContents, err := ioutil.ReadFile("./schema.json") + if err != nil { + log.Fatal(err) + } + + var packageSpec schema.PackageSpec + err = json.Unmarshal(schemaContents, &packageSpec) + if err != nil { + log.Fatalf("cannot deserialize schema: %v", err) + } + + packageSpec.Version = version + versionedContents, err := json.Marshal(packageSpec) + if err != nil { + log.Fatalf("cannot reserialize schema: %v", err) + } + + // Clean up schema.go as it may be present & gitignored and tolerate an error if the file isn't present. + err = os.Remove("./schema.go") + if err != nil && !errors.Is(err, fs.ErrNotExist) { + log.Fatal(err) + } + + err = ioutil.WriteFile("./schema-embed.json", versionedContents, 0600) + if err != nil { + log.Fatal(err) + } +} diff --git a/provider/cmd/pulumi-resource-stackit/main.go b/provider/cmd/pulumi-resource-stackit/main.go new file mode 100644 index 0000000..8a99f56 --- /dev/null +++ b/provider/cmd/pulumi-resource-stackit/main.go @@ -0,0 +1,35 @@ +// Copyright 2016-2018, Pulumi Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//go:generate go run ./generate.go + +package main + +import ( + "context" + _ "embed" + + "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/pf/tfbridge" + stackit "github.com/stackitcloud/pulumi-stackit/provider" +) + +//go:embed schema-embed.json +var pulumiSchema []byte + +func main() { + // Modify the path to point to the new provider + ctx := context.Background() + meta := tfbridge.ProviderMetadata{PackageSchema: pulumiSchema} + tfbridge.Main(ctx, "stackit", stackit.Provider(), meta) +} diff --git a/provider/cmd/pulumi-resource-stackit/schema.json b/provider/cmd/pulumi-resource-stackit/schema.json new file mode 100644 index 0000000..22e01f2 --- /dev/null +++ b/provider/cmd/pulumi-resource-stackit/schema.json @@ -0,0 +1,16563 @@ +{ + "name": "stackit", + "displayName": "stackit", + "description": "A Pulumi package for creating and managing stackit resources.", + "keywords": [ + "pulumi", + "stackit", + "category/utility" + ], + "homepage": "https://www.pulumi.com", + "license": "Apache-2.0", + "attribution": "This Pulumi package is based on the [`stackit` Terraform Provider](https://github.com/stackitcloud/terraform-provider-stackit).", + "repository": "https://github.com/stackitcloud/pulumi-stackit", + "pluginDownloadURL": "github://api.github.com/stackitcloud/pulumi-stackit", + "publisher": "stackitcloud", + "meta": { + "moduleFormat": "(.*)(?:/[^/]*)" + }, + "language": { + "csharp": { + "packageReferences": { + "Pulumi": "3.*" + }, + "compatibility": "tfbridge20" + }, + "go": { + "importBasePath": "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit", + "generateResourceContainerTypes": true, + "generateExtraInputTypes": true + }, + "nodejs": { + "packageName": "@stackitcloud/pulumi-stackit", + "packageDescription": "A Pulumi package for creating and managing stackit resources.", + "readme": "\u003e This provider is a derived work of the [Terraform Provider](https://github.com/stackitcloud/terraform-provider-stackit)\n\u003e distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature,\n\u003e first check the [`pulumi-stackit` repo](https://github.com/stackitcloud/pulumi-stackit/issues); however, if that doesn't turn up anything,\n\u003e please consult the source [`terraform-provider-stackit` repo](https://github.com/stackitcloud/terraform-provider-stackit/issues).", + "dependencies": { + "@pulumi/pulumi": "^3.0.0" + }, + "devDependencies": { + "@types/mime": "^2.0.0", + "@types/node": "^10.0.0" + }, + "compatibility": "tfbridge20", + "disableUnionOutputTypes": true + }, + "python": { + "packageName": "pulumi_stackit", + "requires": { + "pulumi": "\u003e=3.0.0,\u003c4.0.0" + }, + "readme": "\u003e This provider is a derived work of the [Terraform Provider](https://github.com/stackitcloud/terraform-provider-stackit)\n\u003e distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature,\n\u003e first check the [`pulumi-stackit` repo](https://github.com/stackitcloud/pulumi-stackit/issues); however, if that doesn't turn up anything,\n\u003e please consult the source [`terraform-provider-stackit` repo](https://github.com/stackitcloud/terraform-provider-stackit/issues).", + "compatibility": "tfbridge20", + "pyproject": {} + } + }, + "config": { + "variables": { + "argusCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Argus service\n", + "deprecationMessage": "Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality." + }, + "authorizationCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Membership service\n" + }, + "cdnCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the CDN service\n" + }, + "credentialsPath": { + "type": "string", + "description": "Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default\nvalue is `~/.stackit/credentials.json`.\n" + }, + "defaultRegion": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n" + }, + "dnsCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the DNS service\n" + }, + "enableBetaResources": { + "type": "boolean", + "description": "Enable beta resources. Default is false.\n" + }, + "experiments": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Enables experiments. These are unstable features without official support. More information can be found in the README.\nAvailable Experiments: [iam]\n" + }, + "gitCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Git service\n" + }, + "iaasCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the IaaS service\n" + }, + "loadbalancerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Load Balancer service\n" + }, + "logmeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the LogMe service\n" + }, + "mariadbCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MariaDB service\n" + }, + "modelservingCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the AI Model Serving service\n" + }, + "mongodbflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MongoDB Flex service\n" + }, + "objectstorageCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Object Storage service\n" + }, + "observabilityCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Observability service\n" + }, + "opensearchCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the OpenSearch service\n" + }, + "postgresflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the PostgresFlex service\n" + }, + "privateKey": { + "type": "string", + "description": "Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is\nincluded in the service account key.\n" + }, + "privateKeyPath": { + "type": "string", + "description": "Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private\nkey that is included in the service account key.\n" + }, + "rabbitmqCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the RabbitMQ service\n" + }, + "redisCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Redis service\n" + }, + "region": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n", + "deprecationMessage": "This attribute is deprecated. Use 'default_region' instead" + }, + "resourcemanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Resource Manager service\n" + }, + "secretsmanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Secrets Manager service\n" + }, + "serverBackupCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Backup service\n" + }, + "serverUpdateCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Update service\n" + }, + "serviceAccountCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Account service\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required\nif you want to use the resource manager project resource.\n", + "deprecationMessage": "The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025." + }, + "serviceAccountKey": { + "type": "string", + "description": "Service account key used for authentication. If set, the key flow will be used to authenticate all operations.\n" + }, + "serviceAccountKeyPath": { + "type": "string", + "description": "Path for the service account key used for authentication. If set, the key flow will be used to authenticate all\noperations.\n" + }, + "serviceAccountToken": { + "type": "string", + "description": "Token used for authentication. If set, the token flow will be used to authenticate all operations.\n" + }, + "serviceEnablementCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Enablement API\n" + }, + "skeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Kubernetes Engine (SKE) service\n" + }, + "sqlserverflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the SQL Server Flex service\n" + }, + "tokenCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the token API, which is used to request access tokens when using the key flow\n" + } + } + }, + "types": { + "stackit:index/CdnDistributionConfig:CdnDistributionConfig": { + "properties": { + "backend": { + "$ref": "#/types/stackit:index/CdnDistributionConfigBackend:CdnDistributionConfigBackend", + "description": "The configured backend for the distribution\n" + }, + "regions": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The configured regions where content will be hosted\n" + } + }, + "type": "object", + "required": [ + "backend", + "regions" + ] + }, + "stackit:index/CdnDistributionConfigBackend:CdnDistributionConfigBackend": { + "properties": { + "originRequestHeaders": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "The configured origin request headers for the backend\n" + }, + "originUrl": { + "type": "string", + "description": "The configured backend type for the distribution\n" + }, + "type": { + "type": "string", + "description": "The configured backend type. Supported values are: `http`.\n" + } + }, + "type": "object", + "required": [ + "originUrl", + "type" + ] + }, + "stackit:index/CdnDistributionDomain:CdnDistributionDomain": { + "properties": { + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of domain errors\n" + }, + "name": { + "type": "string", + "description": "The name of the domain\n" + }, + "status": { + "type": "string", + "description": "The status of the domain\n" + }, + "type": { + "type": "string", + "description": "The type of the domain. Each distribution has one domain of type \"managed\", and domains of type \"custom\" may be additionally created by the user\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "errors", + "name", + "status", + "type" + ] + } + } + }, + "stackit:index/ImageChecksum:ImageChecksum": { + "properties": { + "algorithm": { + "type": "string", + "description": "Algorithm for the checksum of the image data.\n" + }, + "digest": { + "type": "string", + "description": "Hexdigest of the checksum of the image data.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "algorithm", + "digest" + ] + } + } + }, + "stackit:index/ImageConfig:ImageConfig": { + "properties": { + "bootMenu": { + "type": "boolean", + "description": "Enables the BIOS bootmenu.\n" + }, + "cdromBus": { + "type": "string", + "description": "Sets CDROM bus controller type.\n" + }, + "diskBus": { + "type": "string", + "description": "Sets Disk bus controller type.\n" + }, + "nicModel": { + "type": "string", + "description": "Sets virtual network interface model.\n" + }, + "operatingSystem": { + "type": "string", + "description": "Enables operating system specific optimizations.\n" + }, + "operatingSystemDistro": { + "type": "string", + "description": "Operating system distribution.\n" + }, + "operatingSystemVersion": { + "type": "string", + "description": "Version of the operating system.\n" + }, + "rescueBus": { + "type": "string", + "description": "Sets the device bus when the image is used as a rescue image.\n" + }, + "rescueDevice": { + "type": "string", + "description": "Sets the device when the image is used as a rescue image.\n" + }, + "secureBoot": { + "type": "boolean", + "description": "Enables Secure Boot.\n" + }, + "uefi": { + "type": "boolean", + "description": "Enables UEFI boot.\n" + }, + "videoModel": { + "type": "string", + "description": "Sets Graphic device model.\n" + }, + "virtioScsi": { + "type": "boolean", + "description": "Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "bootMenu", + "cdromBus", + "diskBus", + "nicModel", + "operatingSystem", + "operatingSystemDistro", + "operatingSystemVersion", + "rescueBus", + "rescueDevice", + "secureBoot", + "uefi", + "videoModel", + "virtioScsi" + ] + } + } + }, + "stackit:index/LoadbalancerListener:LoadbalancerListener": { + "properties": { + "displayName": { + "type": "string" + }, + "port": { + "type": "integer", + "description": "Port number where we listen for traffic.\n" + }, + "protocol": { + "type": "string", + "description": "Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`.\n" + }, + "serverNameIndicators": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerListenerServerNameIndicator:LoadbalancerListenerServerNameIndicator" + }, + "description": "A list of domain names to match in order to pass TLS traffic to the target pool in the current listener\n" + }, + "targetPool": { + "type": "string", + "description": "Reference target pool by target pool name.\n" + } + }, + "type": "object", + "required": [ + "port", + "protocol", + "targetPool" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "displayName", + "port", + "protocol", + "targetPool" + ] + } + } + }, + "stackit:index/LoadbalancerListenerServerNameIndicator:LoadbalancerListenerServerNameIndicator": { + "properties": { + "name": { + "type": "string", + "description": "A domain name to match in order to pass TLS traffic to the target pool in the current listener\n" + } + }, + "type": "object" + }, + "stackit:index/LoadbalancerNetwork:LoadbalancerNetwork": { + "properties": { + "networkId": { + "type": "string", + "description": "Openstack network ID.\n" + }, + "role": { + "type": "string", + "description": "The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`.\n" + } + }, + "type": "object", + "required": [ + "networkId", + "role" + ] + }, + "stackit:index/LoadbalancerOptions:LoadbalancerOptions": { + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Load Balancer is accessible only from an IP address in this range.\n" + }, + "observability": { + "$ref": "#/types/stackit:index/LoadbalancerOptionsObservability:LoadbalancerOptionsObservability", + "description": "We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation.\n" + }, + "privateNetworkOnly": { + "type": "boolean", + "description": "If true, Load Balancer is accessible only via a private network IP address.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "acls", + "observability", + "privateNetworkOnly" + ] + } + } + }, + "stackit:index/LoadbalancerOptionsObservability:LoadbalancerOptionsObservability": { + "properties": { + "logs": { + "$ref": "#/types/stackit:index/LoadbalancerOptionsObservabilityLogs:LoadbalancerOptionsObservabilityLogs", + "description": "Observability logs configuration. Not changeable after creation.\n" + }, + "metrics": { + "$ref": "#/types/stackit:index/LoadbalancerOptionsObservabilityMetrics:LoadbalancerOptionsObservabilityMetrics", + "description": "Observability metrics configuration. Not changeable after creation.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "logs", + "metrics" + ] + } + } + }, + "stackit:index/LoadbalancerOptionsObservabilityLogs:LoadbalancerOptionsObservabilityLogs": { + "properties": { + "credentialsRef": { + "type": "string", + "description": "Credentials reference for logs. Not changeable after creation.\n" + }, + "pushUrl": { + "type": "string", + "description": "Credentials reference for logs. Not changeable after creation.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "credentialsRef", + "pushUrl" + ] + } + } + }, + "stackit:index/LoadbalancerOptionsObservabilityMetrics:LoadbalancerOptionsObservabilityMetrics": { + "properties": { + "credentialsRef": { + "type": "string", + "description": "Credentials reference for metrics. Not changeable after creation.\n" + }, + "pushUrl": { + "type": "string", + "description": "Credentials reference for metrics. Not changeable after creation.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "credentialsRef", + "pushUrl" + ] + } + } + }, + "stackit:index/LoadbalancerTargetPool:LoadbalancerTargetPool": { + "properties": { + "activeHealthCheck": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPoolActiveHealthCheck:LoadbalancerTargetPoolActiveHealthCheck" + }, + "name": { + "type": "string", + "description": "Target pool name.\n" + }, + "sessionPersistence": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPoolSessionPersistence:LoadbalancerTargetPoolSessionPersistence", + "description": "Here you can setup various session persistence options, so far only \"`use_source_ip_address`\" is supported.\n" + }, + "targetPort": { + "type": "integer", + "description": "Identical port number where each target listens for traffic.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPoolTarget:LoadbalancerTargetPoolTarget" + }, + "description": "List of all targets which will be used in the pool. Limited to 1000.\n" + } + }, + "type": "object", + "required": [ + "name", + "targetPort", + "targets" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "activeHealthCheck", + "name", + "targetPort", + "targets" + ] + } + } + }, + "stackit:index/LoadbalancerTargetPoolActiveHealthCheck:LoadbalancerTargetPoolActiveHealthCheck": { + "properties": { + "healthyThreshold": { + "type": "integer", + "description": "Healthy threshold of the health checking.\n" + }, + "interval": { + "type": "string", + "description": "Interval duration of health checking in seconds.\n" + }, + "intervalJitter": { + "type": "string", + "description": "Interval duration threshold of the health checking in seconds.\n" + }, + "timeout": { + "type": "string", + "description": "Active health checking timeout duration in seconds.\n" + }, + "unhealthyThreshold": { + "type": "integer", + "description": "Unhealthy threshold of the health checking.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "healthyThreshold", + "interval", + "intervalJitter", + "timeout", + "unhealthyThreshold" + ] + } + } + }, + "stackit:index/LoadbalancerTargetPoolSessionPersistence:LoadbalancerTargetPoolSessionPersistence": { + "properties": { + "useSourceIpAddress": { + "type": "boolean", + "description": "If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev.\n" + } + }, + "type": "object" + }, + "stackit:index/LoadbalancerTargetPoolTarget:LoadbalancerTargetPoolTarget": { + "properties": { + "displayName": { + "type": "string", + "description": "Target display name\n" + }, + "ip": { + "type": "string", + "description": "Target IP\n" + } + }, + "type": "object", + "required": [ + "displayName", + "ip" + ] + }, + "stackit:index/LogmeInstanceParameters:LogmeInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "fluentdTcp": { + "type": "integer" + }, + "fluentdTls": { + "type": "integer" + }, + "fluentdTlsCiphers": { + "type": "string" + }, + "fluentdTlsMaxVersion": { + "type": "string" + }, + "fluentdTlsMinVersion": { + "type": "string" + }, + "fluentdTlsVersion": { + "type": "string" + }, + "fluentdUdp": { + "type": "integer" + }, + "graphite": { + "type": "string", + "description": "If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port).\n" + }, + "ismDeletionAfter": { + "type": "string", + "description": "Combination of an integer and a timerange when an index will be considered \"old\" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`.\n" + }, + "ismJitter": { + "type": "number" + }, + "ismJobInterval": { + "type": "integer", + "description": "Jitter of the execution time.\n" + }, + "javaHeapspace": { + "type": "integer", + "description": "The amount of memory (in MB) allocated as heap by the JVM for OpenSearch.\n" + }, + "javaMaxmetaspace": { + "type": "integer", + "description": "The amount of memory (in MB) used by the JVM to store metadata for OpenSearch.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted (in seconds).\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "opensearchTlsCiphers": { + "type": "array", + "items": { + "type": "string" + } + }, + "opensearchTlsProtocols": { + "type": "array", + "items": { + "type": "string" + } + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "enableMonitoring", + "fluentdTcp", + "fluentdTls", + "fluentdTlsCiphers", + "fluentdTlsMaxVersion", + "fluentdTlsMinVersion", + "fluentdTlsVersion", + "fluentdUdp", + "graphite", + "ismDeletionAfter", + "ismJitter", + "ismJobInterval", + "javaHeapspace", + "javaMaxmetaspace", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "opensearchTlsCiphers", + "opensearchTlsProtocols", + "sgwAcl", + "syslogs" + ] + } + } + }, + "stackit:index/MariadbInstanceParameters:MariadbInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string", + "description": "Graphite server URL (host and port). If set, monitoring with Graphite will be enabled.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance. Monitoring instances with the plan \"Observability-Monitoring-Starter\" are not supported.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "enableMonitoring", + "graphite", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "sgwAcl", + "syslogs" + ] + } + } + }, + "stackit:index/MongodbflexInstanceFlavor:MongodbflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "ram" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "cpu", + "description", + "id", + "ram" + ] + } + } + }, + "stackit:index/MongodbflexInstanceOptions:MongodbflexInstanceOptions": { + "properties": { + "dailySnapshotRetentionDays": { + "type": "integer", + "description": "The number of days that daily backups will be retained.\n" + }, + "monthlySnapshotRetentionMonths": { + "type": "integer", + "description": "The number of months that monthly backups will be retained.\n" + }, + "pointInTimeWindowHours": { + "type": "integer", + "description": "The number of hours back in time the point-in-time recovery feature will be able to recover.\n" + }, + "snapshotRetentionDays": { + "type": "integer", + "description": "The number of days that continuous backups (controlled via the `backup_schedule`) will be retained.\n" + }, + "type": { + "type": "string", + "description": "Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`.\n" + }, + "weeklySnapshotRetentionWeeks": { + "type": "integer", + "description": "The number of weeks that weekly backups will be retained.\n" + } + }, + "type": "object", + "required": [ + "pointInTimeWindowHours", + "type" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "dailySnapshotRetentionDays", + "monthlySnapshotRetentionMonths", + "pointInTimeWindowHours", + "snapshotRetentionDays", + "type", + "weeklySnapshotRetentionWeeks" + ] + } + } + }, + "stackit:index/MongodbflexInstanceStorage:MongodbflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "class", + "size" + ] + }, + "stackit:index/NetworkAreaNetworkRange:NetworkAreaNetworkRange": { + "properties": { + "networkRangeId": { + "type": "string" + }, + "prefix": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR).\n" + } + }, + "type": "object", + "required": [ + "prefix" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "networkRangeId", + "prefix" + ] + } + } + }, + "stackit:index/ObservabilityAlertgroupRule:ObservabilityAlertgroupRule": { + "properties": { + "alert": { + "type": "string", + "description": "The name of the alert rule. Is the identifier and must be unique in the group.\n" + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Annotations to add or overwrite for each alert\n" + }, + "expression": { + "type": "string", + "description": "The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts.\n" + }, + "for": { + "type": "string", + "description": "Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Labels to add or overwrite for each alert\n" + } + }, + "type": "object", + "required": [ + "alert", + "expression" + ] + }, + "stackit:index/ObservabilityInstanceAlertConfig:ObservabilityInstanceAlertConfig": { + "properties": { + "global": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigGlobal:ObservabilityInstanceAlertConfigGlobal", + "description": "Global configuration for the alerts.\n" + }, + "receivers": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigReceiver:ObservabilityInstanceAlertConfigReceiver" + }, + "description": "List of alert receivers.\n" + }, + "route": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigRoute:ObservabilityInstanceAlertConfigRoute", + "description": "Route configuration for the alerts.\n" + } + }, + "type": "object", + "required": [ + "receivers", + "route" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "global", + "receivers", + "route" + ] + } + } + }, + "stackit:index/ObservabilityInstanceAlertConfigGlobal:ObservabilityInstanceAlertConfigGlobal": { + "properties": { + "opsgenieApiKey": { + "type": "string", + "description": "The API key for OpsGenie.\n", + "secret": true + }, + "opsgenieApiUrl": { + "type": "string", + "description": "The host to send OpsGenie API requests to. Must be a valid URL\n" + }, + "resolveTimeout": { + "type": "string", + "description": "The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt.\n" + }, + "smtpAuthIdentity": { + "type": "string", + "description": "SMTP authentication information. Must be a valid email address\n" + }, + "smtpAuthPassword": { + "type": "string", + "description": "SMTP Auth using LOGIN and PLAIN.\n", + "secret": true + }, + "smtpAuthUsername": { + "type": "string", + "description": "SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server.\n" + }, + "smtpFrom": { + "type": "string", + "description": "The default SMTP From header field. Must be a valid email address\n" + }, + "smtpSmartHost": { + "type": "string", + "description": "The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS).\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "resolveTimeout", + "smtpFrom" + ] + } + } + }, + "stackit:index/ObservabilityInstanceAlertConfigReceiver:ObservabilityInstanceAlertConfigReceiver": { + "properties": { + "emailConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigReceiverEmailConfig:ObservabilityInstanceAlertConfigReceiverEmailConfig" + }, + "description": "List of email configurations.\n" + }, + "name": { + "type": "string", + "description": "Name of the receiver.\n" + }, + "opsgenieConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigReceiverOpsgenieConfig:ObservabilityInstanceAlertConfigReceiverOpsgenieConfig" + }, + "description": "List of OpsGenie configurations.\n" + }, + "webhooksConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigReceiverWebhooksConfig:ObservabilityInstanceAlertConfigReceiverWebhooksConfig" + }, + "description": "List of Webhooks configurations.\n" + } + }, + "type": "object", + "required": [ + "name" + ] + }, + "stackit:index/ObservabilityInstanceAlertConfigReceiverEmailConfig:ObservabilityInstanceAlertConfigReceiverEmailConfig": { + "properties": { + "authIdentity": { + "type": "string", + "description": "SMTP authentication information. Must be a valid email address\n" + }, + "authPassword": { + "type": "string", + "description": "SMTP authentication password.\n" + }, + "authUsername": { + "type": "string", + "description": "SMTP authentication username.\n" + }, + "from": { + "type": "string", + "description": "The sender email address. Must be a valid email address\n" + }, + "smartHost": { + "type": "string", + "description": "The SMTP host through which emails are sent.\n" + }, + "to": { + "type": "string", + "description": "The email address to send notifications to. Must be a valid email address\n" + } + }, + "type": "object" + }, + "stackit:index/ObservabilityInstanceAlertConfigReceiverOpsgenieConfig:ObservabilityInstanceAlertConfigReceiverOpsgenieConfig": { + "properties": { + "apiKey": { + "type": "string", + "description": "The API key for OpsGenie.\n" + }, + "apiUrl": { + "type": "string", + "description": "The host to send OpsGenie API requests to. Must be a valid URL\n" + }, + "tags": { + "type": "string", + "description": "Comma separated list of tags attached to the notifications.\n" + } + }, + "type": "object" + }, + "stackit:index/ObservabilityInstanceAlertConfigReceiverWebhooksConfig:ObservabilityInstanceAlertConfigReceiverWebhooksConfig": { + "properties": { + "msTeams": { + "type": "boolean", + "description": "Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams.\n" + }, + "url": { + "type": "string", + "description": "The endpoint to send HTTP POST requests to. Must be a valid URL\n" + } + }, + "type": "object" + }, + "stackit:index/ObservabilityInstanceAlertConfigRoute:ObservabilityInstanceAlertConfigRoute": { + "properties": { + "groupBies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping.\n" + }, + "groupInterval": { + "type": "string", + "description": "How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.)\n" + }, + "groupWait": { + "type": "string", + "description": "How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.)\n" + }, + "match": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of equality matchers an alert has to fulfill to match the node.\n" + }, + "matchRegex": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of regex-matchers an alert has to fulfill to match the node.\n" + }, + "receiver": { + "type": "string", + "description": "The name of the receiver to route the alerts to.\n" + }, + "repeatInterval": { + "type": "string", + "description": "How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more).\n" + }, + "routes": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfigRouteRoute:ObservabilityInstanceAlertConfigRouteRoute" + }, + "description": "List of child routes.\n" + } + }, + "type": "object", + "required": [ + "receiver" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "groupInterval", + "groupWait", + "receiver", + "repeatInterval" + ] + } + } + }, + "stackit:index/ObservabilityInstanceAlertConfigRouteRoute:ObservabilityInstanceAlertConfigRouteRoute": { + "properties": { + "groupBies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping.\n" + }, + "groupInterval": { + "type": "string", + "description": "How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.)\n" + }, + "groupWait": { + "type": "string", + "description": "How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.)\n" + }, + "match": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of equality matchers an alert has to fulfill to match the node.\n" + }, + "matchRegex": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of regex-matchers an alert has to fulfill to match the node.\n" + }, + "receiver": { + "type": "string", + "description": "The name of the receiver to route the alerts to.\n" + }, + "repeatInterval": { + "type": "string", + "description": "How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more).\n" + } + }, + "type": "object", + "required": [ + "receiver" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "groupInterval", + "groupWait", + "receiver", + "repeatInterval" + ] + } + } + }, + "stackit:index/ObservabilityLogalertgroupRule:ObservabilityLogalertgroupRule": { + "properties": { + "alert": { + "type": "string", + "description": "The name of the alert rule. Is the identifier and must be unique in the group.\n" + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Annotations to add or overwrite for each alert\n" + }, + "expression": { + "type": "string", + "description": "The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts.\n" + }, + "for": { + "type": "string", + "description": "Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Labels to add or overwrite for each alert\n" + } + }, + "type": "object", + "required": [ + "alert", + "expression" + ] + }, + "stackit:index/ObservabilityScrapeconfigBasicAuth:ObservabilityScrapeconfigBasicAuth": { + "properties": { + "password": { + "type": "string", + "description": "Specifies basic auth password.\n", + "secret": true + }, + "username": { + "type": "string", + "description": "Specifies basic auth username.\n" + } + }, + "type": "object", + "required": [ + "password", + "username" + ] + }, + "stackit:index/ObservabilityScrapeconfigSaml2:ObservabilityScrapeconfigSaml2": { + "properties": { + "enableUrlParameters": { + "type": "boolean", + "description": "Specifies if URL parameters are enabled. Defaults to `true`\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "enableUrlParameters" + ] + } + } + }, + "stackit:index/ObservabilityScrapeconfigTarget:ObservabilityScrapeconfigTarget": { + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Specifies labels.\n" + }, + "urls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specifies target URLs.\n" + } + }, + "type": "object", + "required": [ + "urls" + ] + }, + "stackit:index/OpensearchInstanceParameters:OpensearchInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string", + "description": "If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port).\n" + }, + "javaGarbageCollector": { + "type": "string", + "description": "The garbage collector to use for OpenSearch.\n" + }, + "javaHeapspace": { + "type": "integer", + "description": "The amount of memory (in MB) allocated as heap by the JVM for OpenSearch.\n" + }, + "javaMaxmetaspace": { + "type": "integer", + "description": "The amount of memory (in MB) used by the JVM to store metadata for OpenSearch.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted (in seconds).\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "plugins": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "The TLS protocol to use.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "enableMonitoring", + "graphite", + "javaGarbageCollector", + "javaHeapspace", + "javaMaxmetaspace", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "plugins", + "sgwAcl", + "syslogs", + "tlsCiphers", + "tlsProtocols" + ] + } + } + }, + "stackit:index/PostgresflexInstanceFlavor:PostgresflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "ram" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "cpu", + "description", + "id", + "ram" + ] + } + } + }, + "stackit:index/PostgresflexInstanceStorage:PostgresflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "class", + "size" + ] + }, + "stackit:index/RabbitmqInstanceParameters:RabbitmqInstanceParameters": { + "properties": { + "consumerTimeout": { + "type": "integer", + "description": "The timeout in milliseconds for the consumer.\n" + }, + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string", + "description": "Graphite server URL (host and port). If set, monitoring with Graphite will be enabled.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "plugins": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of plugins to install. Must be a supported plugin name.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of roles to assign to the instance.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "TLS protocol to use.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "consumerTimeout", + "enableMonitoring", + "graphite", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "plugins", + "roles", + "sgwAcl", + "syslogs", + "tlsCiphers", + "tlsProtocols" + ] + } + } + }, + "stackit:index/RedisInstanceParameters:RedisInstanceParameters": { + "properties": { + "downAfterMilliseconds": { + "type": "integer", + "description": "The number of milliseconds after which the instance is considered down.\n" + }, + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "failoverTimeout": { + "type": "integer", + "description": "The failover timeout in milliseconds.\n" + }, + "graphite": { + "type": "string", + "description": "Graphite server URL (host and port). If set, monitoring with Graphite will be enabled.\n" + }, + "lazyfreeLazyEviction": { + "type": "string", + "description": "The lazy eviction enablement (yes or no).\n" + }, + "lazyfreeLazyExpire": { + "type": "string", + "description": "The lazy expire enablement (yes or no).\n" + }, + "luaTimeLimit": { + "type": "integer", + "description": "The Lua time limit.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "maxclients": { + "type": "integer", + "description": "The maximum number of clients.\n" + }, + "maxmemoryPolicy": { + "type": "string", + "description": "The policy to handle the maximum memory (volatile-lru, noeviction, etc).\n" + }, + "maxmemorySamples": { + "type": "integer", + "description": "The maximum memory samples.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "minReplicasMaxLag": { + "type": "integer", + "description": "The minimum replicas maximum lag.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "notifyKeyspaceEvents": { + "type": "string", + "description": "The notify keyspace events.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "snapshot": { + "type": "string", + "description": "The snapshot configuration.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsCiphersuites": { + "type": "string", + "description": "TLS cipher suites to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "TLS protocol to use.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "downAfterMilliseconds", + "enableMonitoring", + "failoverTimeout", + "graphite", + "lazyfreeLazyEviction", + "lazyfreeLazyExpire", + "luaTimeLimit", + "maxDiskThreshold", + "maxclients", + "maxmemoryPolicy", + "maxmemorySamples", + "metricsFrequency", + "metricsPrefix", + "minReplicasMaxLag", + "monitoringInstanceId", + "notifyKeyspaceEvents", + "sgwAcl", + "snapshot", + "syslogs", + "tlsCiphers", + "tlsCiphersuites", + "tlsProtocols" + ] + } + } + }, + "stackit:index/SecurityGroupRuleIcmpParameters:SecurityGroupRuleIcmpParameters": { + "properties": { + "code": { + "type": "integer", + "description": "ICMP code. Can be set if the protocol is ICMP.\n" + }, + "type": { + "type": "integer", + "description": "ICMP type. Can be set if the protocol is ICMP.\n" + } + }, + "type": "object", + "required": [ + "code", + "type" + ] + }, + "stackit:index/SecurityGroupRulePortRange:SecurityGroupRulePortRange": { + "properties": { + "max": { + "type": "integer", + "description": "The maximum port number. Should be greater or equal to the minimum.\n" + }, + "min": { + "type": "integer", + "description": "The minimum port number. Should be less or equal to the maximum.\n" + } + }, + "type": "object", + "required": [ + "max", + "min" + ] + }, + "stackit:index/SecurityGroupRuleProtocol:SecurityGroupRuleProtocol": { + "properties": { + "name": { + "type": "string", + "description": "The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`.\n" + }, + "number": { + "type": "integer", + "description": "The protocol number which the rule should match. Either `name` or `number` must be provided.\n" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "name", + "number" + ] + } + } + }, + "stackit:index/ServerBackupScheduleBackupProperties:ServerBackupScheduleBackupProperties": { + "properties": { + "name": { + "type": "string" + }, + "retentionPeriod": { + "type": "integer" + }, + "volumeIds": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "type": "object", + "required": [ + "name", + "retentionPeriod" + ] + }, + "stackit:index/ServerBootVolume:ServerBootVolume": { + "properties": { + "deleteOnTermination": { + "type": "boolean", + "description": "Delete the volume during the termination of the server. Only allowed when `source_type` is `image`.\n" + }, + "id": { + "type": "string", + "description": "The ID of the boot volume\n" + }, + "performanceClass": { + "type": "string", + "description": "The performance class of the server.\n" + }, + "size": { + "type": "integer", + "description": "The size of the boot volume in GB. Must be provided when `source_type` is `image`.\n" + }, + "sourceId": { + "type": "string", + "description": "The ID of the source, either image ID or volume ID\n" + }, + "sourceType": { + "type": "string", + "description": "The type of the source. Supported values are: `volume`, `image`.\n" + } + }, + "type": "object", + "required": [ + "sourceId", + "sourceType" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "deleteOnTermination", + "id", + "sourceId", + "sourceType" + ] + } + } + }, + "stackit:index/SkeClusterExtensions:SkeClusterExtensions": { + "properties": { + "acl": { + "$ref": "#/types/stackit:index/SkeClusterExtensionsAcl:SkeClusterExtensionsAcl", + "description": "Cluster access control configuration.\n" + }, + "argus": { + "$ref": "#/types/stackit:index/SkeClusterExtensionsArgus:SkeClusterExtensionsArgus", + "description": "A single argus block as defined below.\n" + }, + "dns": { + "$ref": "#/types/stackit:index/SkeClusterExtensionsDns:SkeClusterExtensionsDns", + "description": "DNS extension configuration\n" + } + }, + "type": "object" + }, + "stackit:index/SkeClusterExtensionsAcl:SkeClusterExtensionsAcl": { + "properties": { + "allowedCidrs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of CIDRs to whitelist.\n" + }, + "enabled": { + "type": "boolean", + "description": "Is ACL enabled?\n" + } + }, + "type": "object", + "required": [ + "allowedCidrs", + "enabled" + ] + }, + "stackit:index/SkeClusterExtensionsArgus:SkeClusterExtensionsArgus": { + "properties": { + "argusInstanceId": { + "type": "string", + "description": "Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`.\n" + }, + "enabled": { + "type": "boolean", + "description": "Flag to enable/disable Argus extensions.\n" + } + }, + "type": "object", + "required": [ + "enabled" + ] + }, + "stackit:index/SkeClusterExtensionsDns:SkeClusterExtensionsDns": { + "properties": { + "enabled": { + "type": "boolean", + "description": "Flag to enable/disable DNS extensions\n" + }, + "zones": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`)\n" + } + }, + "type": "object", + "required": [ + "enabled" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "enabled", + "zones" + ] + } + } + }, + "stackit:index/SkeClusterHibernation:SkeClusterHibernation": { + "properties": { + "end": { + "type": "string", + "description": "End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am.\n" + }, + "start": { + "type": "string", + "description": "Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm.\n" + }, + "timezone": { + "type": "string", + "description": "Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`.\n" + } + }, + "type": "object", + "required": [ + "end", + "start" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "end", + "start", + "timezone" + ] + } + } + }, + "stackit:index/SkeClusterMaintenance:SkeClusterMaintenance": { + "properties": { + "enableKubernetesVersionUpdates": { + "type": "boolean", + "description": "Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "enableMachineImageVersionUpdates": { + "type": "boolean", + "description": "Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "end": { + "type": "string", + "description": "Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`.\n" + }, + "start": { + "type": "string", + "description": "Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`.\n" + } + }, + "type": "object", + "required": [ + "end", + "start" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "enableKubernetesVersionUpdates", + "enableMachineImageVersionUpdates", + "end", + "start" + ] + } + } + }, + "stackit:index/SkeClusterNetwork:SkeClusterNetwork": { + "properties": { + "id": { + "type": "string", + "description": "ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed.\n" + } + }, + "type": "object" + }, + "stackit:index/SkeClusterNodePool:SkeClusterNodePool": { + "properties": { + "allowSystemComponents": { + "type": "boolean", + "description": "Allow system components to run on this node pool.\n" + }, + "availabilityZones": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of availability zones. E.g. `eu01-m`\n" + }, + "cri": { + "type": "string", + "description": "Specifies the container runtime. Defaults to `containerd`\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels to add to each node.\n" + }, + "machineType": { + "type": "string", + "description": "The machine type.\n" + }, + "maxSurge": { + "type": "integer", + "description": "Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time.\n" + }, + "maxUnavailable": { + "type": "integer", + "description": "Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time.\n" + }, + "maximum": { + "type": "integer", + "description": "Maximum number of nodes in the pool.\n" + }, + "minimum": { + "type": "integer", + "description": "Minimum number of nodes in the pool.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the node pool.\n" + }, + "osName": { + "type": "string", + "description": "The name of the OS image. Defaults to `flatcar`.\n" + }, + "osVersion": { + "type": "string", + "description": "This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead.\n", + "deprecationMessage": "Use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates." + }, + "osVersionMin": { + "type": "string", + "description": "The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field.\n" + }, + "osVersionUsed": { + "type": "string", + "description": "Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "taints": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterNodePoolTaint:SkeClusterNodePoolTaint" + }, + "description": "Specifies a taint list as defined below.\n" + }, + "volumeSize": { + "type": "integer", + "description": "The volume size in GB. Defaults to `20`\n" + }, + "volumeType": { + "type": "string", + "description": "Specifies the volume type. Defaults to `storage_premium_perf1`.\n" + } + }, + "type": "object", + "required": [ + "availabilityZones", + "machineType", + "maximum", + "minimum", + "name" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "allowSystemComponents", + "availabilityZones", + "cri", + "labels", + "machineType", + "maxSurge", + "maxUnavailable", + "maximum", + "minimum", + "name", + "osName", + "osVersionUsed", + "volumeSize", + "volumeType" + ] + } + } + }, + "stackit:index/SkeClusterNodePoolTaint:SkeClusterNodePoolTaint": { + "properties": { + "effect": { + "type": "string", + "description": "The taint effect. E.g `PreferNoSchedule`.\n" + }, + "key": { + "type": "string", + "description": "Taint key to be applied to a node.\n" + }, + "value": { + "type": "string", + "description": "Taint value corresponding to the taint key.\n" + } + }, + "type": "object", + "required": [ + "effect", + "key" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "effect", + "key", + "value" + ] + } + } + }, + "stackit:index/SqlserverflexInstanceFlavor:SqlserverflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "ram" + ], + "language": { + "nodejs": { + "requiredOutputs": [ + "cpu", + "description", + "id", + "ram" + ] + } + } + }, + "stackit:index/SqlserverflexInstanceOptions:SqlserverflexInstanceOptions": { + "properties": { + "edition": { + "type": "string" + }, + "retentionDays": { + "type": "integer" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "edition", + "retentionDays" + ] + } + } + }, + "stackit:index/SqlserverflexInstanceStorage:SqlserverflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "language": { + "nodejs": { + "requiredOutputs": [ + "class", + "size" + ] + } + } + }, + "stackit:index/VolumeSource:VolumeSource": { + "properties": { + "id": { + "type": "string", + "description": "The ID of the source, e.g. image ID\n" + }, + "type": { + "type": "string", + "description": "The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`.\n" + } + }, + "type": "object", + "required": [ + "id", + "type" + ] + }, + "stackit:index/getCdnDistributionConfig:getCdnDistributionConfig": { + "properties": { + "backend": { + "$ref": "#/types/stackit:index/getCdnDistributionConfigBackend:getCdnDistributionConfigBackend", + "description": "The configured backend for the distribution\n" + }, + "regions": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The configured regions where content will be hosted\n" + } + }, + "type": "object", + "required": [ + "backend", + "regions" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getCdnDistributionConfigBackend:getCdnDistributionConfigBackend": { + "properties": { + "originRequestHeaders": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "The configured origin request headers for the backend\n" + }, + "originUrl": { + "type": "string", + "description": "The configured backend type for the distribution\n" + }, + "type": { + "type": "string", + "description": "The configured backend type. Supported values are: `http`.\n" + } + }, + "type": "object", + "required": [ + "originRequestHeaders", + "originUrl", + "type" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getCdnDistributionDomain:getCdnDistributionDomain": { + "properties": { + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of domain errors\n" + }, + "name": { + "type": "string", + "description": "The name of the domain\n" + }, + "status": { + "type": "string", + "description": "The status of the domain\n" + }, + "type": { + "type": "string", + "description": "The type of the domain. Each distribution has one domain of type \"managed\", and domains of type \"custom\" may be additionally created by the user\n" + } + }, + "type": "object", + "required": [ + "errors", + "name", + "status", + "type" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getImageChecksum:getImageChecksum": { + "properties": { + "algorithm": { + "type": "string", + "description": "Algorithm for the checksum of the image data.\n" + }, + "digest": { + "type": "string", + "description": "Hexdigest of the checksum of the image data.\n" + } + }, + "type": "object", + "required": [ + "algorithm", + "digest" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getImageConfig:getImageConfig": { + "properties": { + "bootMenu": { + "type": "boolean", + "description": "Enables the BIOS bootmenu.\n" + }, + "cdromBus": { + "type": "string", + "description": "Sets CDROM bus controller type.\n" + }, + "diskBus": { + "type": "string", + "description": "Sets Disk bus controller type.\n" + }, + "nicModel": { + "type": "string", + "description": "Sets virtual network interface model.\n" + }, + "operatingSystem": { + "type": "string", + "description": "Enables operating system specific optimizations.\n" + }, + "operatingSystemDistro": { + "type": "string", + "description": "Operating system distribution.\n" + }, + "operatingSystemVersion": { + "type": "string", + "description": "Version of the operating system.\n" + }, + "rescueBus": { + "type": "string", + "description": "Sets the device bus when the image is used as a rescue image.\n" + }, + "rescueDevice": { + "type": "string", + "description": "Sets the device when the image is used as a rescue image.\n" + }, + "secureBoot": { + "type": "boolean", + "description": "Enables Secure Boot.\n" + }, + "uefi": { + "type": "boolean", + "description": "Enables UEFI boot.\n" + }, + "videoModel": { + "type": "string", + "description": "Sets Graphic device model.\n" + }, + "virtioScsi": { + "type": "boolean", + "description": "Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block.\n" + } + }, + "type": "object", + "required": [ + "bootMenu", + "cdromBus", + "diskBus", + "nicModel", + "operatingSystem", + "operatingSystemDistro", + "operatingSystemVersion", + "rescueBus", + "rescueDevice", + "secureBoot", + "uefi", + "videoModel", + "virtioScsi" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerListener:getLoadbalancerListener": { + "properties": { + "displayName": { + "type": "string" + }, + "port": { + "type": "integer", + "description": "Port number where we listen for traffic.\n" + }, + "protocol": { + "type": "string", + "description": "Protocol is the highest network protocol we understand to load balance.\n" + }, + "serverNameIndicators": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getLoadbalancerListenerServerNameIndicator:getLoadbalancerListenerServerNameIndicator" + }, + "description": "A list of domain names to match in order to pass TLS traffic to the target pool in the current listener\n" + }, + "targetPool": { + "type": "string", + "description": "Reference target pool by target pool name.\n" + } + }, + "type": "object", + "required": [ + "displayName", + "port", + "protocol", + "targetPool" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerListenerServerNameIndicator:getLoadbalancerListenerServerNameIndicator": { + "properties": { + "name": { + "type": "string", + "description": "A domain name to match in order to pass TLS traffic to the target pool in the current listener\n" + } + }, + "type": "object" + }, + "stackit:index/getLoadbalancerNetwork:getLoadbalancerNetwork": { + "properties": { + "networkId": { + "type": "string", + "description": "Openstack network ID.\n" + }, + "role": { + "type": "string", + "description": "The role defines how the load balancer is using the network.\n" + } + }, + "type": "object", + "required": [ + "networkId", + "role" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerOptions:getLoadbalancerOptions": { + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Load Balancer is accessible only from an IP address in this range.\n" + }, + "observability": { + "$ref": "#/types/stackit:index/getLoadbalancerOptionsObservability:getLoadbalancerOptionsObservability", + "description": "We offer Load Balancer metrics observability via ARGUS or external solutions.\n" + }, + "privateNetworkOnly": { + "type": "boolean", + "description": "If true, Load Balancer is accessible only via a private network IP address.\n" + } + }, + "type": "object", + "required": [ + "acls", + "observability", + "privateNetworkOnly" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerOptionsObservability:getLoadbalancerOptionsObservability": { + "properties": { + "logs": { + "$ref": "#/types/stackit:index/getLoadbalancerOptionsObservabilityLogs:getLoadbalancerOptionsObservabilityLogs", + "description": "Observability logs configuration.\n" + }, + "metrics": { + "$ref": "#/types/stackit:index/getLoadbalancerOptionsObservabilityMetrics:getLoadbalancerOptionsObservabilityMetrics", + "description": "Observability metrics configuration.\n" + } + }, + "type": "object", + "required": [ + "logs", + "metrics" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerOptionsObservabilityLogs:getLoadbalancerOptionsObservabilityLogs": { + "properties": { + "credentialsRef": { + "type": "string", + "description": "Credentials reference for logs.\n" + }, + "pushUrl": { + "type": "string", + "description": "Credentials reference for logs.\n" + } + }, + "type": "object", + "required": [ + "credentialsRef", + "pushUrl" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerOptionsObservabilityMetrics:getLoadbalancerOptionsObservabilityMetrics": { + "properties": { + "credentialsRef": { + "type": "string", + "description": "Credentials reference for metrics.\n" + }, + "pushUrl": { + "type": "string", + "description": "Credentials reference for metrics.\n" + } + }, + "type": "object", + "required": [ + "credentialsRef", + "pushUrl" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerTargetPool:getLoadbalancerTargetPool": { + "properties": { + "activeHealthCheck": { + "$ref": "#/types/stackit:index/getLoadbalancerTargetPoolActiveHealthCheck:getLoadbalancerTargetPoolActiveHealthCheck" + }, + "name": { + "type": "string", + "description": "Target pool name.\n" + }, + "sessionPersistence": { + "$ref": "#/types/stackit:index/getLoadbalancerTargetPoolSessionPersistence:getLoadbalancerTargetPoolSessionPersistence", + "description": "Here you can setup various session persistence options, so far only \"`use_source_ip_address`\" is supported.\n" + }, + "targetPort": { + "type": "integer", + "description": "Identical port number where each target listens for traffic.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getLoadbalancerTargetPoolTarget:getLoadbalancerTargetPoolTarget" + }, + "description": "List of all targets which will be used in the pool. Limited to 1000.\n" + } + }, + "type": "object", + "required": [ + "activeHealthCheck", + "name", + "targetPort", + "targets" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerTargetPoolActiveHealthCheck:getLoadbalancerTargetPoolActiveHealthCheck": { + "properties": { + "healthyThreshold": { + "type": "integer", + "description": "Healthy threshold of the health checking.\n" + }, + "interval": { + "type": "string", + "description": "Interval duration of health checking in seconds.\n" + }, + "intervalJitter": { + "type": "string", + "description": "Interval duration threshold of the health checking in seconds.\n" + }, + "timeout": { + "type": "string", + "description": "Active health checking timeout duration in seconds.\n" + }, + "unhealthyThreshold": { + "type": "integer", + "description": "Unhealthy threshold of the health checking.\n" + } + }, + "type": "object", + "required": [ + "healthyThreshold", + "interval", + "intervalJitter", + "timeout", + "unhealthyThreshold" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLoadbalancerTargetPoolSessionPersistence:getLoadbalancerTargetPoolSessionPersistence": { + "properties": { + "useSourceIpAddress": { + "type": "boolean", + "description": "If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev.\n" + } + }, + "type": "object" + }, + "stackit:index/getLoadbalancerTargetPoolTarget:getLoadbalancerTargetPoolTarget": { + "properties": { + "displayName": { + "type": "string", + "description": "Target display name\n" + }, + "ip": { + "type": "string", + "description": "Target IP\n" + } + }, + "type": "object", + "required": [ + "displayName", + "ip" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getLogmeInstanceParameters:getLogmeInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "fluentdTcp": { + "type": "integer" + }, + "fluentdTls": { + "type": "integer" + }, + "fluentdTlsCiphers": { + "type": "string" + }, + "fluentdTlsMaxVersion": { + "type": "string" + }, + "fluentdTlsMinVersion": { + "type": "string" + }, + "fluentdTlsVersion": { + "type": "string" + }, + "fluentdUdp": { + "type": "integer" + }, + "graphite": { + "type": "string", + "description": "If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port).\n" + }, + "ismDeletionAfter": { + "type": "string", + "description": "Combination of an integer and a timerange when an index will be considered \"old\" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`.\n" + }, + "ismJitter": { + "type": "number" + }, + "ismJobInterval": { + "type": "integer", + "description": "Jitter of the execution time.\n" + }, + "javaHeapspace": { + "type": "integer", + "description": "The amount of memory (in MB) allocated as heap by the JVM for OpenSearch.\n" + }, + "javaMaxmetaspace": { + "type": "integer", + "description": "The amount of memory (in MB) used by the JVM to store metadata for OpenSearch.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted (in seconds).\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "opensearchTlsCiphers": { + "type": "array", + "items": { + "type": "string" + } + }, + "opensearchTlsProtocols": { + "type": "array", + "items": { + "type": "string" + } + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + } + }, + "type": "object", + "required": [ + "enableMonitoring", + "fluentdTcp", + "fluentdTls", + "fluentdTlsCiphers", + "fluentdTlsMaxVersion", + "fluentdTlsMinVersion", + "fluentdTlsVersion", + "fluentdUdp", + "graphite", + "ismDeletionAfter", + "ismJitter", + "ismJobInterval", + "javaHeapspace", + "javaMaxmetaspace", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "opensearchTlsCiphers", + "opensearchTlsProtocols", + "sgwAcl", + "syslogs" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getMariadbInstanceParameters:getMariadbInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + } + }, + "type": "object", + "required": [ + "enableMonitoring", + "graphite", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "sgwAcl", + "syslogs" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getMongodbflexInstanceFlavor:getMongodbflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "description", + "id", + "ram" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getMongodbflexInstanceOptions:getMongodbflexInstanceOptions": { + "properties": { + "dailySnapshotRetentionDays": { + "type": "integer", + "description": "The number of days that daily backups will be retained.\n" + }, + "monthlySnapshotRetentionMonths": { + "type": "integer", + "description": "The number of months that monthly backups will be retained.\n" + }, + "pointInTimeWindowHours": { + "type": "integer", + "description": "The number of hours back in time the point-in-time recovery feature will be able to recover.\n" + }, + "snapshotRetentionDays": { + "type": "integer", + "description": "The number of days that continuous backups (controlled via the `backup_schedule`) will be retained.\n" + }, + "type": { + "type": "string", + "description": "Type of the MongoDB Flex instance.\n" + }, + "weeklySnapshotRetentionWeeks": { + "type": "integer", + "description": "The number of weeks that weekly backups will be retained.\n" + } + }, + "type": "object", + "required": [ + "dailySnapshotRetentionDays", + "monthlySnapshotRetentionMonths", + "pointInTimeWindowHours", + "snapshotRetentionDays", + "type", + "weeklySnapshotRetentionWeeks" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getMongodbflexInstanceStorage:getMongodbflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "class", + "size" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getNetworkAreaNetworkRange:getNetworkAreaNetworkRange": { + "properties": { + "networkRangeId": { + "type": "string" + }, + "prefix": { + "type": "string" + } + }, + "type": "object", + "required": [ + "networkRangeId", + "prefix" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityAlertgroupRule:getObservabilityAlertgroupRule": { + "properties": { + "alert": { + "type": "string", + "description": "The name of the alert rule. Is the identifier and must be unique in the group.\n" + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Annotations to add or overwrite for each alert\n" + }, + "expression": { + "type": "string", + "description": "The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts.\n" + }, + "for": { + "type": "string", + "description": "Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Labels to add or overwrite for each alert\n" + } + }, + "type": "object", + "required": [ + "alert", + "annotations", + "expression", + "for", + "labels" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfig:getObservabilityInstanceAlertConfig": { + "properties": { + "global": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigGlobal:getObservabilityInstanceAlertConfigGlobal", + "description": "Global configuration for the alerts.\n" + }, + "receivers": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigReceiver:getObservabilityInstanceAlertConfigReceiver" + }, + "description": "List of alert receivers.\n" + }, + "route": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigRoute:getObservabilityInstanceAlertConfigRoute", + "description": "The route for the alert.\n" + } + }, + "type": "object", + "required": [ + "global", + "receivers", + "route" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigGlobal:getObservabilityInstanceAlertConfigGlobal": { + "properties": { + "opsgenieApiKey": { + "type": "string", + "description": "The API key for OpsGenie.\n", + "secret": true + }, + "opsgenieApiUrl": { + "type": "string", + "description": "The host to send OpsGenie API requests to. Must be a valid URL\n" + }, + "resolveTimeout": { + "type": "string", + "description": "The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt.\n" + }, + "smtpAuthIdentity": { + "type": "string", + "description": "SMTP authentication information. Must be a valid email address\n" + }, + "smtpAuthPassword": { + "type": "string", + "description": "SMTP Auth using LOGIN and PLAIN.\n", + "secret": true + }, + "smtpAuthUsername": { + "type": "string", + "description": "SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server.\n" + }, + "smtpFrom": { + "type": "string", + "description": "The default SMTP From header field. Must be a valid email address\n" + }, + "smtpSmartHost": { + "type": "string", + "description": "The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS).\n" + } + }, + "type": "object", + "required": [ + "opsgenieApiKey", + "opsgenieApiUrl", + "resolveTimeout", + "smtpAuthIdentity", + "smtpAuthPassword", + "smtpAuthUsername", + "smtpFrom", + "smtpSmartHost" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigReceiver:getObservabilityInstanceAlertConfigReceiver": { + "properties": { + "emailConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigReceiverEmailConfig:getObservabilityInstanceAlertConfigReceiverEmailConfig" + }, + "description": "List of email configurations.\n" + }, + "name": { + "type": "string", + "description": "Name of the receiver.\n" + }, + "opsgenieConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigReceiverOpsgenieConfig:getObservabilityInstanceAlertConfigReceiverOpsgenieConfig" + }, + "description": "List of OpsGenie configurations.\n" + }, + "webhooksConfigs": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigReceiverWebhooksConfig:getObservabilityInstanceAlertConfigReceiverWebhooksConfig" + }, + "description": "List of Webhooks configurations.\n" + } + }, + "type": "object", + "required": [ + "emailConfigs", + "name", + "opsgenieConfigs", + "webhooksConfigs" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigReceiverEmailConfig:getObservabilityInstanceAlertConfigReceiverEmailConfig": { + "properties": { + "authIdentity": { + "type": "string", + "description": "SMTP authentication information. Must be a valid email address\n" + }, + "authPassword": { + "type": "string", + "description": "SMTP authentication password.\n" + }, + "authUsername": { + "type": "string", + "description": "SMTP authentication username.\n" + }, + "from": { + "type": "string", + "description": "The sender email address. Must be a valid email address\n" + }, + "smartHost": { + "type": "string", + "description": "The SMTP host through which emails are sent.\n" + }, + "to": { + "type": "string", + "description": "The email address to send notifications to. Must be a valid email address\n" + } + }, + "type": "object", + "required": [ + "authIdentity", + "authPassword", + "authUsername", + "from", + "smartHost", + "to" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigReceiverOpsgenieConfig:getObservabilityInstanceAlertConfigReceiverOpsgenieConfig": { + "properties": { + "apiKey": { + "type": "string", + "description": "The API key for OpsGenie.\n" + }, + "apiUrl": { + "type": "string", + "description": "The host to send OpsGenie API requests to. Must be a valid URL\n" + }, + "tags": { + "type": "string", + "description": "Comma separated list of tags attached to the notifications.\n" + } + }, + "type": "object", + "required": [ + "apiKey", + "apiUrl", + "tags" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigReceiverWebhooksConfig:getObservabilityInstanceAlertConfigReceiverWebhooksConfig": { + "properties": { + "msTeams": { + "type": "boolean", + "description": "Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams.\n" + }, + "url": { + "type": "string", + "description": "The endpoint to send HTTP POST requests to. Must be a valid URL\n" + } + }, + "type": "object", + "required": [ + "msTeams", + "url" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigRoute:getObservabilityInstanceAlertConfigRoute": { + "properties": { + "groupBies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping.\n" + }, + "groupInterval": { + "type": "string", + "description": "How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.)\n" + }, + "groupWait": { + "type": "string", + "description": "How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) .\n" + }, + "match": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of equality matchers an alert has to fulfill to match the node.\n" + }, + "matchRegex": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of regex-matchers an alert has to fulfill to match the node.\n" + }, + "receiver": { + "type": "string", + "description": "The name of the receiver to route the alerts to.\n" + }, + "repeatInterval": { + "type": "string", + "description": "How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more).\n" + }, + "routes": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfigRouteRoute:getObservabilityInstanceAlertConfigRouteRoute" + }, + "description": "List of child routes.\n" + } + }, + "type": "object", + "required": [ + "groupBies", + "groupInterval", + "groupWait", + "match", + "matchRegex", + "receiver", + "repeatInterval", + "routes" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityInstanceAlertConfigRouteRoute:getObservabilityInstanceAlertConfigRouteRoute": { + "properties": { + "groupBies": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping.\n" + }, + "groupInterval": { + "type": "string", + "description": "How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.)\n" + }, + "groupWait": { + "type": "string", + "description": "How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.)\n" + }, + "match": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of equality matchers an alert has to fulfill to match the node.\n" + }, + "matchRegex": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A set of regex-matchers an alert has to fulfill to match the node.\n" + }, + "receiver": { + "type": "string", + "description": "The name of the receiver to route the alerts to.\n" + }, + "repeatInterval": { + "type": "string", + "description": "How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more).\n" + } + }, + "type": "object", + "required": [ + "groupBies", + "groupInterval", + "groupWait", + "match", + "matchRegex", + "receiver", + "repeatInterval" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityLogalertgroupRule:getObservabilityLogalertgroupRule": { + "properties": { + "alert": { + "type": "string", + "description": "The name of the alert rule. Is the identifier and must be unique in the group.\n" + }, + "annotations": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Annotations to add or overwrite for each alert\n" + }, + "expression": { + "type": "string", + "description": "The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts.\n" + }, + "for": { + "type": "string", + "description": "Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of key:value. Labels to add or overwrite for each alert\n" + } + }, + "type": "object", + "required": [ + "alert", + "annotations", + "expression", + "for", + "labels" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityScrapeconfigBasicAuth:getObservabilityScrapeconfigBasicAuth": { + "properties": { + "password": { + "type": "string", + "description": "Specifies basic auth password.\n", + "secret": true + }, + "username": { + "type": "string", + "description": "Specifies basic auth username.\n" + } + }, + "type": "object", + "required": [ + "password", + "username" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityScrapeconfigSaml2:getObservabilityScrapeconfigSaml2": { + "properties": { + "enableUrlParameters": { + "type": "boolean", + "description": "Specifies if URL parameters are enabled\n" + } + }, + "type": "object", + "required": [ + "enableUrlParameters" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getObservabilityScrapeconfigTarget:getObservabilityScrapeconfigTarget": { + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Specifies labels.\n" + }, + "urls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specifies target URLs.\n" + } + }, + "type": "object", + "required": [ + "labels", + "urls" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getOpensearchInstanceParameters:getOpensearchInstanceParameters": { + "properties": { + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string", + "description": "If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port).\n" + }, + "javaGarbageCollector": { + "type": "string", + "description": "The garbage collector to use for OpenSearch.\n" + }, + "javaHeapspace": { + "type": "integer", + "description": "The amount of memory (in MB) allocated as heap by the JVM for OpenSearch.\n" + }, + "javaMaxmetaspace": { + "type": "integer", + "description": "The amount of memory (in MB) used by the JVM to store metadata for OpenSearch.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted (in seconds).\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "plugins": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "The TLS protocol to use.\n" + } + }, + "type": "object", + "required": [ + "enableMonitoring", + "graphite", + "javaGarbageCollector", + "javaHeapspace", + "javaMaxmetaspace", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "plugins", + "sgwAcl", + "syslogs", + "tlsCiphers", + "tlsProtocols" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getPostgresflexInstanceFlavor:getPostgresflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "description", + "id", + "ram" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getPostgresflexInstanceStorage:getPostgresflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "class", + "size" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getPublicIpRangesPublicIpRange:getPublicIpRangesPublicIpRange": { + "properties": { + "cidr": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR)\n" + } + }, + "type": "object", + "required": [ + "cidr" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getRabbitmqInstanceParameters:getRabbitmqInstanceParameters": { + "properties": { + "consumerTimeout": { + "type": "integer", + "description": "The timeout in milliseconds for the consumer.\n" + }, + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "graphite": { + "type": "string", + "description": "Graphite server URL (host and port). If set, monitoring with Graphite will be enabled.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "plugins": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of plugins to install. Must be a supported plugin name.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of roles to assign to the instance.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "TLS protocol to use.\n" + } + }, + "type": "object", + "required": [ + "consumerTimeout", + "enableMonitoring", + "graphite", + "maxDiskThreshold", + "metricsFrequency", + "metricsPrefix", + "monitoringInstanceId", + "plugins", + "roles", + "sgwAcl", + "syslogs", + "tlsCiphers", + "tlsProtocols" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getRedisInstanceParameters:getRedisInstanceParameters": { + "properties": { + "downAfterMilliseconds": { + "type": "integer", + "description": "The number of milliseconds after which the instance is considered down.\n" + }, + "enableMonitoring": { + "type": "boolean", + "description": "Enable monitoring.\n" + }, + "failoverTimeout": { + "type": "integer", + "description": "The failover timeout in milliseconds.\n" + }, + "graphite": { + "type": "string", + "description": "Graphite server URL (host and port). If set, monitoring with Graphite will be enabled.\n" + }, + "lazyfreeLazyEviction": { + "type": "string", + "description": "The lazy eviction enablement (yes or no).\n" + }, + "lazyfreeLazyExpire": { + "type": "string", + "description": "The lazy expire enablement (yes or no).\n" + }, + "luaTimeLimit": { + "type": "integer", + "description": "The Lua time limit.\n" + }, + "maxDiskThreshold": { + "type": "integer", + "description": "The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped.\n" + }, + "maxclients": { + "type": "integer", + "description": "The maximum number of clients.\n" + }, + "maxmemoryPolicy": { + "type": "string", + "description": "The policy to handle the maximum memory (volatile-lru, noeviction, etc).\n" + }, + "maxmemorySamples": { + "type": "integer", + "description": "The maximum memory samples.\n" + }, + "metricsFrequency": { + "type": "integer", + "description": "The frequency in seconds at which metrics are emitted.\n" + }, + "metricsPrefix": { + "type": "string", + "description": "The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key\n" + }, + "minReplicasMaxLag": { + "type": "integer", + "description": "The minimum replicas maximum lag.\n" + }, + "monitoringInstanceId": { + "type": "string", + "description": "The ID of the STACKIT monitoring instance.\n" + }, + "notifyKeyspaceEvents": { + "type": "string", + "description": "The notify keyspace events.\n" + }, + "sgwAcl": { + "type": "string", + "description": "Comma separated list of IP networks in CIDR notation which are allowed to access this instance.\n" + }, + "snapshot": { + "type": "string", + "description": "The snapshot configuration.\n" + }, + "syslogs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of syslog servers to send logs to.\n" + }, + "tlsCiphers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of TLS ciphers to use.\n" + }, + "tlsCiphersuites": { + "type": "string", + "description": "TLS cipher suites to use.\n" + }, + "tlsProtocols": { + "type": "string", + "description": "TLS protocol to use.\n" + } + }, + "type": "object", + "required": [ + "downAfterMilliseconds", + "enableMonitoring", + "failoverTimeout", + "graphite", + "lazyfreeLazyEviction", + "lazyfreeLazyExpire", + "luaTimeLimit", + "maxDiskThreshold", + "maxclients", + "maxmemoryPolicy", + "maxmemorySamples", + "metricsFrequency", + "metricsPrefix", + "minReplicasMaxLag", + "monitoringInstanceId", + "notifyKeyspaceEvents", + "sgwAcl", + "snapshot", + "syslogs", + "tlsCiphers", + "tlsCiphersuites", + "tlsProtocols" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSecurityGroupRuleIcmpParameters:getSecurityGroupRuleIcmpParameters": { + "properties": { + "code": { + "type": "integer", + "description": "ICMP code. Can be set if the protocol is ICMP.\n" + }, + "type": { + "type": "integer", + "description": "ICMP type. Can be set if the protocol is ICMP.\n" + } + }, + "type": "object", + "required": [ + "code", + "type" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSecurityGroupRulePortRange:getSecurityGroupRulePortRange": { + "properties": { + "max": { + "type": "integer", + "description": "The maximum port number. Should be greater or equal to the minimum.\n" + }, + "min": { + "type": "integer", + "description": "The minimum port number. Should be less or equal to the minimum.\n" + } + }, + "type": "object", + "required": [ + "max", + "min" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSecurityGroupRuleProtocol:getSecurityGroupRuleProtocol": { + "properties": { + "name": { + "type": "string", + "description": "The protocol name which the rule should match.\n" + }, + "number": { + "type": "integer", + "description": "The protocol number which the rule should match.\n" + } + }, + "type": "object", + "required": [ + "name", + "number" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getServerBackupScheduleBackupProperties:getServerBackupScheduleBackupProperties": { + "properties": { + "name": { + "type": "string" + }, + "retentionPeriod": { + "type": "integer" + }, + "volumeIds": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "type": "object", + "required": [ + "name", + "retentionPeriod", + "volumeIds" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getServerBackupSchedulesItem:getServerBackupSchedulesItem": { + "properties": { + "backupProperties": { + "$ref": "#/types/stackit:index/getServerBackupSchedulesItemBackupProperties:getServerBackupSchedulesItemBackupProperties", + "description": "Backup schedule details for the backups.\n" + }, + "backupScheduleId": { + "type": "integer" + }, + "enabled": { + "type": "boolean", + "description": "Is the backup schedule enabled or disabled.\n" + }, + "name": { + "type": "string", + "description": "The backup schedule name.\n" + }, + "rrule": { + "type": "string", + "description": "Backup schedule described in `rrule` (recurrence rule) format.\n" + } + }, + "type": "object", + "required": [ + "backupProperties", + "backupScheduleId", + "enabled", + "name", + "rrule" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getServerBackupSchedulesItemBackupProperties:getServerBackupSchedulesItemBackupProperties": { + "properties": { + "name": { + "type": "string" + }, + "retentionPeriod": { + "type": "integer" + }, + "volumeIds": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "type": "object", + "required": [ + "name", + "retentionPeriod", + "volumeIds" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getServerBootVolume:getServerBootVolume": { + "properties": { + "deleteOnTermination": { + "type": "boolean", + "description": "Delete the volume during the termination of the server.\n" + }, + "id": { + "type": "string", + "description": "The ID of the boot volume\n" + } + }, + "type": "object", + "required": [ + "deleteOnTermination", + "id" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getServerUpdateSchedulesItem:getServerUpdateSchedulesItem": { + "properties": { + "enabled": { + "type": "boolean", + "description": "Is the update schedule enabled or disabled.\n" + }, + "maintenanceWindow": { + "type": "integer", + "description": "Maintenance window [1..24].\n" + }, + "name": { + "type": "string", + "description": "The update schedule name.\n" + }, + "rrule": { + "type": "string", + "description": "Update schedule described in `rrule` (recurrence rule) format.\n" + }, + "updateScheduleId": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "enabled", + "maintenanceWindow", + "name", + "rrule", + "updateScheduleId" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterExtensions:getSkeClusterExtensions": { + "properties": { + "acl": { + "$ref": "#/types/stackit:index/getSkeClusterExtensionsAcl:getSkeClusterExtensionsAcl", + "description": "Cluster access control configuration\n" + }, + "argus": { + "$ref": "#/types/stackit:index/getSkeClusterExtensionsArgus:getSkeClusterExtensionsArgus", + "description": "A single argus block as defined below\n" + }, + "dns": { + "$ref": "#/types/stackit:index/getSkeClusterExtensionsDns:getSkeClusterExtensionsDns", + "description": "DNS extension configuration\n" + } + }, + "type": "object", + "required": [ + "acl", + "argus", + "dns" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterExtensionsAcl:getSkeClusterExtensionsAcl": { + "properties": { + "allowedCidrs": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of CIDRs to whitelist\n" + }, + "enabled": { + "type": "boolean", + "description": "Is ACL enabled?\n" + } + }, + "type": "object", + "required": [ + "allowedCidrs", + "enabled" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterExtensionsArgus:getSkeClusterExtensionsArgus": { + "properties": { + "argusInstanceId": { + "type": "string", + "description": "Instance ID of argus\n" + }, + "enabled": { + "type": "boolean", + "description": "Flag to enable/disable argus extensions.\n" + } + }, + "type": "object", + "required": [ + "argusInstanceId", + "enabled" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterExtensionsDns:getSkeClusterExtensionsDns": { + "properties": { + "enabled": { + "type": "boolean", + "description": "Flag to enable/disable DNS extensions\n" + }, + "zones": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`)\n" + } + }, + "type": "object", + "required": [ + "enabled", + "zones" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterHibernation:getSkeClusterHibernation": { + "properties": { + "end": { + "type": "string", + "description": "End time of hibernation, in crontab syntax.\n" + }, + "start": { + "type": "string", + "description": "Start time of cluster hibernation in crontab syntax.\n" + }, + "timezone": { + "type": "string", + "description": "Timezone name corresponding to a file in the IANA Time Zone database.\n" + } + }, + "type": "object", + "required": [ + "end", + "start", + "timezone" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterMaintenance:getSkeClusterMaintenance": { + "properties": { + "enableKubernetesVersionUpdates": { + "type": "boolean", + "description": "Flag to enable/disable auto-updates of the Kubernetes version.\n" + }, + "enableMachineImageVersionUpdates": { + "type": "boolean", + "description": "Flag to enable/disable auto-updates of the OS image version.\n" + }, + "end": { + "type": "string", + "description": "Date time for maintenance window end.\n" + }, + "start": { + "type": "string", + "description": "Date time for maintenance window start.\n" + } + }, + "type": "object", + "required": [ + "enableKubernetesVersionUpdates", + "enableMachineImageVersionUpdates", + "end", + "start" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterNetwork:getSkeClusterNetwork": { + "properties": { + "id": { + "type": "string", + "description": "ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed.\n" + } + }, + "type": "object", + "required": [ + "id" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterNodePool:getSkeClusterNodePool": { + "properties": { + "allowSystemComponents": { + "type": "boolean", + "description": "Allow system components to run on this node pool.\n" + }, + "availabilityZones": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Specify a list of availability zones.\n" + }, + "cri": { + "type": "string", + "description": "Specifies the container runtime.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels to add to each node.\n" + }, + "machineType": { + "type": "string", + "description": "The machine type.\n" + }, + "maxSurge": { + "type": "integer", + "description": "The maximum number of nodes upgraded simultaneously.\n" + }, + "maxUnavailable": { + "type": "integer", + "description": "The maximum number of nodes unavailable during upgraded.\n" + }, + "maximum": { + "type": "integer", + "description": "Maximum number of nodes in the pool.\n" + }, + "minimum": { + "type": "integer", + "description": "Minimum number of nodes in the pool.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the node pool.\n" + }, + "osName": { + "type": "string", + "description": "The name of the OS image.\n" + }, + "osVersion": { + "type": "string", + "description": "The OS image version.\n" + }, + "osVersionMin": { + "type": "string", + "description": "The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field.\n" + }, + "osVersionUsed": { + "type": "string", + "description": "Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "taints": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getSkeClusterNodePoolTaint:getSkeClusterNodePoolTaint" + }, + "description": "Specifies a taint list as defined below.\n" + }, + "volumeSize": { + "type": "integer", + "description": "The volume size in GB.\n" + }, + "volumeType": { + "type": "string", + "description": "Specifies the volume type.\n" + } + }, + "type": "object", + "required": [ + "allowSystemComponents", + "availabilityZones", + "cri", + "labels", + "machineType", + "maxSurge", + "maxUnavailable", + "maximum", + "minimum", + "name", + "osName", + "osVersion", + "osVersionMin", + "osVersionUsed", + "taints", + "volumeSize", + "volumeType" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSkeClusterNodePoolTaint:getSkeClusterNodePoolTaint": { + "properties": { + "effect": { + "type": "string", + "description": "The taint effect.\n" + }, + "key": { + "type": "string", + "description": "Taint key to be applied to a node.\n" + }, + "value": { + "type": "string", + "description": "Taint value corresponding to the taint key.\n" + } + }, + "type": "object", + "required": [ + "effect", + "key", + "value" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSqlserverflexInstanceFlavor:getSqlserverflexInstanceFlavor": { + "properties": { + "cpu": { + "type": "integer" + }, + "description": { + "type": "string" + }, + "id": { + "type": "string" + }, + "ram": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "cpu", + "description", + "id", + "ram" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSqlserverflexInstanceOptions:getSqlserverflexInstanceOptions": { + "properties": { + "edition": { + "type": "string" + }, + "retentionDays": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "edition", + "retentionDays" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getSqlserverflexInstanceStorage:getSqlserverflexInstanceStorage": { + "properties": { + "class": { + "type": "string" + }, + "size": { + "type": "integer" + } + }, + "type": "object", + "required": [ + "class", + "size" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, + "stackit:index/getVolumeSource:getVolumeSource": { + "properties": { + "id": { + "type": "string", + "description": "The ID of the source, e.g. image ID\n" + }, + "type": { + "type": "string", + "description": "The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`.\n" + } + }, + "type": "object", + "required": [ + "id", + "type" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + } + }, + "provider": { + "description": "The provider type for the stackit package. By default, resources use package-wide configuration\nsettings, however an explicit `Provider` instance may be created and passed during resource\nconstruction to achieve fine-grained programmatic control over provider settings. See the\n[documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information.\n", + "properties": { + "argusCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Argus service\n", + "deprecationMessage": "Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality." + }, + "authorizationCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Membership service\n" + }, + "cdnCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the CDN service\n" + }, + "credentialsPath": { + "type": "string", + "description": "Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default\nvalue is `~/.stackit/credentials.json`.\n" + }, + "defaultRegion": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n" + }, + "dnsCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the DNS service\n" + }, + "enableBetaResources": { + "type": "boolean", + "description": "Enable beta resources. Default is false.\n" + }, + "experiments": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Enables experiments. These are unstable features without official support. More information can be found in the README.\nAvailable Experiments: [iam]\n" + }, + "gitCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Git service\n" + }, + "iaasCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the IaaS service\n" + }, + "loadbalancerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Load Balancer service\n" + }, + "logmeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the LogMe service\n" + }, + "mariadbCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MariaDB service\n" + }, + "modelservingCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the AI Model Serving service\n" + }, + "mongodbflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MongoDB Flex service\n" + }, + "objectstorageCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Object Storage service\n" + }, + "observabilityCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Observability service\n" + }, + "opensearchCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the OpenSearch service\n" + }, + "postgresflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the PostgresFlex service\n" + }, + "privateKey": { + "type": "string", + "description": "Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is\nincluded in the service account key.\n" + }, + "privateKeyPath": { + "type": "string", + "description": "Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private\nkey that is included in the service account key.\n" + }, + "rabbitmqCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the RabbitMQ service\n" + }, + "redisCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Redis service\n" + }, + "region": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n", + "deprecationMessage": "This attribute is deprecated. Use 'default_region' instead" + }, + "resourcemanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Resource Manager service\n" + }, + "secretsmanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Secrets Manager service\n" + }, + "serverBackupCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Backup service\n" + }, + "serverUpdateCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Update service\n" + }, + "serviceAccountCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Account service\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required\nif you want to use the resource manager project resource.\n", + "deprecationMessage": "The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025." + }, + "serviceAccountKey": { + "type": "string", + "description": "Service account key used for authentication. If set, the key flow will be used to authenticate all operations.\n" + }, + "serviceAccountKeyPath": { + "type": "string", + "description": "Path for the service account key used for authentication. If set, the key flow will be used to authenticate all\noperations.\n" + }, + "serviceAccountToken": { + "type": "string", + "description": "Token used for authentication. If set, the token flow will be used to authenticate all operations.\n" + }, + "serviceEnablementCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Enablement API\n" + }, + "skeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Kubernetes Engine (SKE) service\n" + }, + "sqlserverflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the SQL Server Flex service\n" + }, + "tokenCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the token API, which is used to request access tokens when using the key flow\n" + } + }, + "inputProperties": { + "argusCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Argus service\n", + "deprecationMessage": "Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality." + }, + "authorizationCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Membership service\n" + }, + "cdnCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the CDN service\n" + }, + "credentialsPath": { + "type": "string", + "description": "Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default\nvalue is `~/.stackit/credentials.json`.\n" + }, + "defaultRegion": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n" + }, + "dnsCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the DNS service\n" + }, + "enableBetaResources": { + "type": "boolean", + "description": "Enable beta resources. Default is false.\n" + }, + "experiments": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Enables experiments. These are unstable features without official support. More information can be found in the README.\nAvailable Experiments: [iam]\n" + }, + "gitCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Git service\n" + }, + "iaasCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the IaaS service\n" + }, + "loadbalancerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Load Balancer service\n" + }, + "logmeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the LogMe service\n" + }, + "mariadbCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MariaDB service\n" + }, + "modelservingCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the AI Model Serving service\n" + }, + "mongodbflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the MongoDB Flex service\n" + }, + "objectstorageCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Object Storage service\n" + }, + "observabilityCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Observability service\n" + }, + "opensearchCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the OpenSearch service\n" + }, + "postgresflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the PostgresFlex service\n" + }, + "privateKey": { + "type": "string", + "description": "Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is\nincluded in the service account key.\n" + }, + "privateKeyPath": { + "type": "string", + "description": "Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private\nkey that is included in the service account key.\n" + }, + "rabbitmqCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the RabbitMQ service\n" + }, + "redisCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Redis service\n" + }, + "region": { + "type": "string", + "description": "Region will be used as the default location for regional services. Not all services require a region, some are global\n", + "deprecationMessage": "This attribute is deprecated. Use 'default_region' instead" + }, + "resourcemanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Resource Manager service\n" + }, + "secretsmanagerCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Secrets Manager service\n" + }, + "serverBackupCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Backup service\n" + }, + "serverUpdateCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Server Update service\n" + }, + "serviceAccountCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Account service\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required\nif you want to use the resource manager project resource.\n", + "deprecationMessage": "The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025." + }, + "serviceAccountKey": { + "type": "string", + "description": "Service account key used for authentication. If set, the key flow will be used to authenticate all operations.\n" + }, + "serviceAccountKeyPath": { + "type": "string", + "description": "Path for the service account key used for authentication. If set, the key flow will be used to authenticate all\noperations.\n" + }, + "serviceAccountToken": { + "type": "string", + "description": "Token used for authentication. If set, the token flow will be used to authenticate all operations.\n" + }, + "serviceEnablementCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Service Enablement API\n" + }, + "skeCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the Kubernetes Engine (SKE) service\n" + }, + "sqlserverflexCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the SQL Server Flex service\n" + }, + "tokenCustomEndpoint": { + "type": "string", + "description": "Custom endpoint for the token API, which is used to request access tokens when using the key flow\n" + } + }, + "methods": { + "terraformConfig": "pulumi:providers:stackit/terraformConfig" + } + }, + "resources": { + "stackit:index/affinityGroup:AffinityGroup": { + "description": "Affinity Group schema. Must have a `region` specified in the provider configuration.\n\n\n\n## Example Usage\n\n```terraform\nresource \"stackit_affinity_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-affinity-group-name\"\n policy = \"hard-anti-affinity\"\n}\n```\n", + "properties": { + "affinityGroupId": { + "type": "string", + "description": "The affinity group ID.\n" + }, + "members": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The servers that are part of the affinity group.\n" + }, + "name": { + "type": "string", + "description": "The name of the affinity group.\n" + }, + "policy": { + "type": "string", + "description": "The policy of the affinity group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the affinity group is associated.\n" + } + }, + "required": [ + "affinityGroupId", + "members", + "name", + "policy", + "projectId" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "The name of the affinity group.\n" + }, + "policy": { + "type": "string", + "description": "The policy of the affinity group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the affinity group is associated.\n" + } + }, + "requiredInputs": [ + "policy", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering AffinityGroup resources.\n", + "properties": { + "affinityGroupId": { + "type": "string", + "description": "The affinity group ID.\n" + }, + "members": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The servers that are part of the affinity group.\n" + }, + "name": { + "type": "string", + "description": "The name of the affinity group.\n" + }, + "policy": { + "type": "string", + "description": "The policy of the affinity group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the affinity group is associated.\n" + } + }, + "type": "object" + } + }, + "stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment": { + "description": "organization Role Assignment resource schema.\n\n\u003e This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion.\n\n## Example Usage\n\n```terraform\nresource \"stackit_authorization_organization_role_assignment\" \"example\" {\n resource_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n role = \"owner\"\n subject = \"john.doe@stackit.cloud\"\n}\n```\n", + "properties": { + "resourceId": { + "type": "string", + "description": "organization Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "required": [ + "resourceId", + "role", + "subject" + ], + "inputProperties": { + "resourceId": { + "type": "string", + "description": "organization Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "requiredInputs": [ + "resourceId", + "role", + "subject" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering AuthorizationOrganizationRoleAssignment resources.\n", + "properties": { + "resourceId": { + "type": "string", + "description": "organization Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "type": "object" + } + }, + "stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment": { + "description": "project Role Assignment resource schema.\n\n\u003e This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion.\n\n## Example Usage\n\n```terraform\nresource \"stackit_authorization_project_role_assignment\" \"example\" {\n resource_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n role = \"owner\"\n subject = \"john.doe@stackit.cloud\"\n}\n```\n", + "properties": { + "resourceId": { + "type": "string", + "description": "project Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "required": [ + "resourceId", + "role", + "subject" + ], + "inputProperties": { + "resourceId": { + "type": "string", + "description": "project Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "requiredInputs": [ + "resourceId", + "role", + "subject" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering AuthorizationProjectRoleAssignment resources.\n", + "properties": { + "resourceId": { + "type": "string", + "description": "project Resource to assign the role to.\n" + }, + "role": { + "type": "string", + "description": "Role to be assigned\n" + }, + "subject": { + "type": "string", + "description": "Identifier of user, service account or client. Usually email address or name in case of clients\n" + } + }, + "type": "object" + } + }, + "stackit:index/cdnCustomDomain:CdnCustomDomain": { + "description": "CDN distribution data source schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\nresource \"stackit_cdn_custom_domain\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n distribution_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"https://xxx.xxx\"\n}\n```\n", + "properties": { + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + } + }, + "required": [ + "distributionId", + "errors", + "name", + "projectId", + "status" + ], + "inputProperties": { + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + } + }, + "requiredInputs": [ + "distributionId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering CdnCustomDomain resources.\n", + "properties": { + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + } + }, + "type": "object" + } + }, + "stackit:index/cdnDistribution:CdnDistribution": { + "description": "CDN distribution data source schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\nresource \"stackit_cdn_distribution\" \"example_distribution\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n config = {\n backend = {\n type = \"http\"\n origin_url = \"mybackend.onstackit.cloud\"\n }\n regions = [\"EU\", \"US\", \"ASIA\", \"AF\", \"SA\"]\n }\n}\n```\n", + "properties": { + "config": { + "$ref": "#/types/stackit:index/CdnDistributionConfig:CdnDistributionConfig", + "description": "The distribution configuration\n" + }, + "createdAt": { + "type": "string", + "description": "Time when the distribution was created\n" + }, + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "domains": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/CdnDistributionDomain:CdnDistributionDomain" + }, + "description": "List of configured domains for the distribution\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + }, + "updatedAt": { + "type": "string", + "description": "Time when the distribution was last updated\n" + } + }, + "required": [ + "config", + "createdAt", + "distributionId", + "domains", + "errors", + "projectId", + "status", + "updatedAt" + ], + "inputProperties": { + "config": { + "$ref": "#/types/stackit:index/CdnDistributionConfig:CdnDistributionConfig", + "description": "The distribution configuration\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + } + }, + "requiredInputs": [ + "config", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering CdnDistribution resources.\n", + "properties": { + "config": { + "$ref": "#/types/stackit:index/CdnDistributionConfig:CdnDistributionConfig", + "description": "The distribution configuration\n" + }, + "createdAt": { + "type": "string", + "description": "Time when the distribution was created\n" + }, + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "domains": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/CdnDistributionDomain:CdnDistributionDomain" + }, + "description": "List of configured domains for the distribution\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + }, + "updatedAt": { + "type": "string", + "description": "Time when the distribution was last updated\n" + } + }, + "type": "object" + } + }, + "stackit:index/dnsRecordSet:DnsRecordSet": { + "description": "DNS Record Set Resource schema.\n\n## Example Usage\n\n```terraform\nresource \"stackit_dns_record_set\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n zone_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-record-set\"\n type = \"A\"\n comment = \"Example comment\"\n records = [\"1.2.3.4\"]\n}\n```\n", + "properties": { + "active": { + "type": "boolean", + "description": "Specifies if the record set is active or not. Defaults to `true`\n" + }, + "comment": { + "type": "string", + "description": "Comment.\n" + }, + "error": { + "type": "string", + "description": "Error shows error in case create/update/delete failed.\n" + }, + "fqdn": { + "type": "string", + "description": "Fully qualified domain name (FQDN) of the record set.\n" + }, + "name": { + "type": "string", + "description": "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns record set is associated.\n" + }, + "recordSetId": { + "type": "string", + "description": "The rr set id.\n" + }, + "records": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Records.\n" + }, + "state": { + "type": "string", + "description": "Record set state.\n" + }, + "ttl": { + "type": "integer", + "description": "Time to live. E.g. 3600\n" + }, + "type": { + "type": "string", + "description": "The record set type. E.g. `A` or `CNAME`\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID to which is dns record set is associated.\n" + } + }, + "required": [ + "active", + "comment", + "error", + "fqdn", + "name", + "projectId", + "recordSetId", + "records", + "state", + "ttl", + "type", + "zoneId" + ], + "inputProperties": { + "active": { + "type": "boolean", + "description": "Specifies if the record set is active or not. Defaults to `true`\n" + }, + "comment": { + "type": "string", + "description": "Comment.\n" + }, + "name": { + "type": "string", + "description": "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns record set is associated.\n" + }, + "records": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Records.\n" + }, + "ttl": { + "type": "integer", + "description": "Time to live. E.g. 3600\n" + }, + "type": { + "type": "string", + "description": "The record set type. E.g. `A` or `CNAME`\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID to which is dns record set is associated.\n" + } + }, + "requiredInputs": [ + "projectId", + "records", + "type", + "zoneId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering DnsRecordSet resources.\n", + "properties": { + "active": { + "type": "boolean", + "description": "Specifies if the record set is active or not. Defaults to `true`\n" + }, + "comment": { + "type": "string", + "description": "Comment.\n" + }, + "error": { + "type": "string", + "description": "Error shows error in case create/update/delete failed.\n" + }, + "fqdn": { + "type": "string", + "description": "Fully qualified domain name (FQDN) of the record set.\n" + }, + "name": { + "type": "string", + "description": "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns record set is associated.\n" + }, + "recordSetId": { + "type": "string", + "description": "The rr set id.\n" + }, + "records": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Records.\n" + }, + "state": { + "type": "string", + "description": "Record set state.\n" + }, + "ttl": { + "type": "integer", + "description": "Time to live. E.g. 3600\n" + }, + "type": { + "type": "string", + "description": "The record set type. E.g. `A` or `CNAME`\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID to which is dns record set is associated.\n" + } + }, + "type": "object" + } + }, + "stackit:index/dnsZone:DnsZone": { + "description": "DNS Zone resource schema.\n\n## Example Usage\n\n```terraform\nresource \"stackit_dns_zone\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"Example zone\"\n dns_name = \"example-zone.com\"\n contact_email = \"aa@bb.ccc\"\n type = \"primary\"\n acl = \"192.168.0.0/24\"\n description = \"Example description\"\n default_ttl = 1230\n}\n```\n", + "properties": { + "acl": { + "type": "string", + "description": "The access control list. E.g. `0.0.0.0/0,::/0`\n" + }, + "active": { + "type": "boolean" + }, + "contactEmail": { + "type": "string", + "description": "A contact e-mail for the zone.\n" + }, + "defaultTtl": { + "type": "integer", + "description": "Default time to live. E.g. 3600.\n" + }, + "description": { + "type": "string", + "description": "Description of the zone.\n" + }, + "dnsName": { + "type": "string", + "description": "The zone name. E.g. `example.com`\n" + }, + "expireTime": { + "type": "integer", + "description": "Expire time. E.g. 1209600.\n" + }, + "isReverseZone": { + "type": "boolean", + "description": "Specifies, if the zone is a reverse zone or not. Defaults to `false`\n" + }, + "name": { + "type": "string", + "description": "The user given name of the zone.\n" + }, + "negativeCache": { + "type": "integer", + "description": "Negative caching. E.g. 60\n" + }, + "primaries": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Primary name server for secondary zone. E.g. [\"1.2.3.4\"]\n" + }, + "primaryNameServer": { + "type": "string", + "description": "Primary name server. FQDN.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns zone is associated.\n" + }, + "recordCount": { + "type": "integer", + "description": "Record count how many records are in the zone.\n" + }, + "refreshTime": { + "type": "integer", + "description": "Refresh time. E.g. 3600\n" + }, + "retryTime": { + "type": "integer", + "description": "Retry time. E.g. 600\n" + }, + "serialNumber": { + "type": "integer", + "description": "Serial number. E.g. `2022111400`.\n" + }, + "state": { + "type": "string", + "description": "Zone state. E.g. `CREATE_SUCCEEDED`.\n" + }, + "type": { + "type": "string", + "description": "Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`.\n" + }, + "visibility": { + "type": "string", + "description": "Visibility of the zone. E.g. `public`.\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID.\n" + } + }, + "required": [ + "acl", + "active", + "contactEmail", + "defaultTtl", + "description", + "dnsName", + "expireTime", + "isReverseZone", + "name", + "negativeCache", + "primaries", + "primaryNameServer", + "projectId", + "recordCount", + "refreshTime", + "retryTime", + "serialNumber", + "state", + "type", + "visibility", + "zoneId" + ], + "inputProperties": { + "acl": { + "type": "string", + "description": "The access control list. E.g. `0.0.0.0/0,::/0`\n" + }, + "active": { + "type": "boolean" + }, + "contactEmail": { + "type": "string", + "description": "A contact e-mail for the zone.\n" + }, + "defaultTtl": { + "type": "integer", + "description": "Default time to live. E.g. 3600.\n" + }, + "description": { + "type": "string", + "description": "Description of the zone.\n" + }, + "dnsName": { + "type": "string", + "description": "The zone name. E.g. `example.com`\n" + }, + "expireTime": { + "type": "integer", + "description": "Expire time. E.g. 1209600.\n" + }, + "isReverseZone": { + "type": "boolean", + "description": "Specifies, if the zone is a reverse zone or not. Defaults to `false`\n" + }, + "name": { + "type": "string", + "description": "The user given name of the zone.\n" + }, + "negativeCache": { + "type": "integer", + "description": "Negative caching. E.g. 60\n" + }, + "primaries": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Primary name server for secondary zone. E.g. [\"1.2.3.4\"]\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns zone is associated.\n" + }, + "refreshTime": { + "type": "integer", + "description": "Refresh time. E.g. 3600\n" + }, + "retryTime": { + "type": "integer", + "description": "Retry time. E.g. 600\n" + }, + "type": { + "type": "string", + "description": "Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`.\n" + } + }, + "requiredInputs": [ + "dnsName", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering DnsZone resources.\n", + "properties": { + "acl": { + "type": "string", + "description": "The access control list. E.g. `0.0.0.0/0,::/0`\n" + }, + "active": { + "type": "boolean" + }, + "contactEmail": { + "type": "string", + "description": "A contact e-mail for the zone.\n" + }, + "defaultTtl": { + "type": "integer", + "description": "Default time to live. E.g. 3600.\n" + }, + "description": { + "type": "string", + "description": "Description of the zone.\n" + }, + "dnsName": { + "type": "string", + "description": "The zone name. E.g. `example.com`\n" + }, + "expireTime": { + "type": "integer", + "description": "Expire time. E.g. 1209600.\n" + }, + "isReverseZone": { + "type": "boolean", + "description": "Specifies, if the zone is a reverse zone or not. Defaults to `false`\n" + }, + "name": { + "type": "string", + "description": "The user given name of the zone.\n" + }, + "negativeCache": { + "type": "integer", + "description": "Negative caching. E.g. 60\n" + }, + "primaries": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Primary name server for secondary zone. E.g. [\"1.2.3.4\"]\n" + }, + "primaryNameServer": { + "type": "string", + "description": "Primary name server. FQDN.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns zone is associated.\n" + }, + "recordCount": { + "type": "integer", + "description": "Record count how many records are in the zone.\n" + }, + "refreshTime": { + "type": "integer", + "description": "Refresh time. E.g. 3600\n" + }, + "retryTime": { + "type": "integer", + "description": "Retry time. E.g. 600\n" + }, + "serialNumber": { + "type": "integer", + "description": "Serial number. E.g. `2022111400`.\n" + }, + "state": { + "type": "string", + "description": "Zone state. E.g. `CREATE_SUCCEEDED`.\n" + }, + "type": { + "type": "string", + "description": "Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`.\n" + }, + "visibility": { + "type": "string", + "description": "Visibility of the zone. E.g. `public`.\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/git:Git": { + "description": "Git Instance resource schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\nresource \"stackit_git\" \"git\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"git-example-instance\"\n}\n```\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID linked to the git instance.\n" + }, + "name": { + "type": "string", + "description": "Unique name linked to the git instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the git instance is associated.\n" + }, + "url": { + "type": "string", + "description": "Url linked to the git instance.\n" + }, + "version": { + "type": "string", + "description": "Version linked to the git instance.\n" + } + }, + "required": [ + "instanceId", + "name", + "projectId", + "url", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Unique name linked to the git instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the git instance is associated.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Git resources.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID linked to the git instance.\n" + }, + "name": { + "type": "string", + "description": "Unique name linked to the git instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the git instance is associated.\n" + }, + "url": { + "type": "string", + "description": "Url linked to the git instance.\n" + }, + "version": { + "type": "string", + "description": "Version linked to the git instance.\n" + } + }, + "type": "object" + } + }, + "stackit:index/image:Image": { + "description": "Image resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_image\" \"example_image\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-image\"\n disk_format = \"qcow2\"\n local_file_path = \"./path/to/image.qcow2\"\n min_disk_size = 10\n min_ram = 5\n}\n```\n", + "properties": { + "checksum": { + "$ref": "#/types/stackit:index/ImageChecksum:ImageChecksum", + "description": "Representation of an image checksum.\n" + }, + "config": { + "$ref": "#/types/stackit:index/ImageConfig:ImageConfig", + "description": "Properties to set hardware and scheduling settings for an image.\n" + }, + "diskFormat": { + "type": "string", + "description": "The disk format of the image.\n" + }, + "imageId": { + "type": "string", + "description": "The image ID.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "localFilePath": { + "type": "string", + "description": "The filepath of the raw image file to be uploaded.\n" + }, + "minDiskSize": { + "type": "integer", + "description": "The minimum disk size of the image in GB.\n" + }, + "minRam": { + "type": "integer", + "description": "The minimum RAM of the image in MB.\n" + }, + "name": { + "type": "string", + "description": "The name of the image.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the image is associated.\n" + }, + "protected": { + "type": "boolean", + "description": "Whether the image is protected.\n" + }, + "scope": { + "type": "string", + "description": "The scope of the image.\n" + } + }, + "required": [ + "checksum", + "config", + "diskFormat", + "imageId", + "localFilePath", + "minDiskSize", + "minRam", + "name", + "projectId", + "protected", + "scope" + ], + "inputProperties": { + "config": { + "$ref": "#/types/stackit:index/ImageConfig:ImageConfig", + "description": "Properties to set hardware and scheduling settings for an image.\n" + }, + "diskFormat": { + "type": "string", + "description": "The disk format of the image.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "localFilePath": { + "type": "string", + "description": "The filepath of the raw image file to be uploaded.\n" + }, + "minDiskSize": { + "type": "integer", + "description": "The minimum disk size of the image in GB.\n" + }, + "minRam": { + "type": "integer", + "description": "The minimum RAM of the image in MB.\n" + }, + "name": { + "type": "string", + "description": "The name of the image.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the image is associated.\n" + } + }, + "requiredInputs": [ + "diskFormat", + "localFilePath", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Image resources.\n", + "properties": { + "checksum": { + "$ref": "#/types/stackit:index/ImageChecksum:ImageChecksum", + "description": "Representation of an image checksum.\n" + }, + "config": { + "$ref": "#/types/stackit:index/ImageConfig:ImageConfig", + "description": "Properties to set hardware and scheduling settings for an image.\n" + }, + "diskFormat": { + "type": "string", + "description": "The disk format of the image.\n" + }, + "imageId": { + "type": "string", + "description": "The image ID.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "localFilePath": { + "type": "string", + "description": "The filepath of the raw image file to be uploaded.\n" + }, + "minDiskSize": { + "type": "integer", + "description": "The minimum disk size of the image in GB.\n" + }, + "minRam": { + "type": "integer", + "description": "The minimum RAM of the image in MB.\n" + }, + "name": { + "type": "string", + "description": "The name of the image.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the image is associated.\n" + }, + "protected": { + "type": "boolean", + "description": "Whether the image is protected.\n" + }, + "scope": { + "type": "string", + "description": "The scope of the image.\n" + } + }, + "type": "object" + } + }, + "stackit:index/keyPair:KeyPair": { + "description": "Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication.\n", + "properties": { + "fingerprint": { + "type": "string", + "description": "The fingerprint of the public SSH key.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container.\n" + }, + "name": { + "type": "string", + "description": "The name of the SSH key pair.\n" + }, + "publicKey": { + "type": "string", + "description": "A string representation of the public SSH key. E.g., `ssh-rsa \u003ckey_data\u003e` or `ssh-ed25519 \u003ckey-data\u003e`.\n" + } + }, + "required": [ + "fingerprint", + "name", + "publicKey" + ], + "inputProperties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container.\n" + }, + "name": { + "type": "string", + "description": "The name of the SSH key pair.\n" + }, + "publicKey": { + "type": "string", + "description": "A string representation of the public SSH key. E.g., `ssh-rsa \u003ckey_data\u003e` or `ssh-ed25519 \u003ckey-data\u003e`.\n" + } + }, + "requiredInputs": [ + "publicKey" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering KeyPair resources.\n", + "properties": { + "fingerprint": { + "type": "string", + "description": "The fingerprint of the public SSH key.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container.\n" + }, + "name": { + "type": "string", + "description": "The name of the SSH key pair.\n" + }, + "publicKey": { + "type": "string", + "description": "A string representation of the public SSH key. E.g., `ssh-rsa \u003ckey_data\u003e` or `ssh-ed25519 \u003ckey-data\u003e`.\n" + } + }, + "type": "object" + } + }, + "stackit:index/loadbalancer:Loadbalancer": { + "description": "## Example Usage\n\n```terraform\n# Create a network\nresource \"stackit_network\" \"example_network\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-network\"\n ipv4_nameservers = [\"8.8.8.8\"]\n ipv4_prefix = \"192.168.0.0/25\"\n labels = {\n \"key\" = \"value\"\n }\n routed = true\n}\n\n# Create a network interface\nresource \"stackit_network_interface\" \"nic\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_id = stackit_network.example_network.network_id\n}\n\n# Create a public IP for the load balancer\nresource \"stackit_public_ip\" \"public-ip\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n lifecycle {\n ignore_changes = [network_interface_id]\n }\n}\n\n# Create a key pair for accessing the server instance\nresource \"stackit_key_pair\" \"keypair\" {\n name = \"example-key-pair\"\n public_key = chomp(file(\"path/to/id_rsa.pub\"))\n}\n\n# Create a server instance\nresource \"stackit_server\" \"boot-from-image\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-server\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"59838a89-51b1-4892-b57f-b3caf598ee2f\" // Ubuntu 24.04\n }\n availability_zone = \"xxxx-x\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n network_interfaces = [\n stackit_network_interface.nic.network_interface_id\n ]\n}\n\n# Create a load balancer\nresource \"stackit_loadbalancer\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-load-balancer\"\n target_pools = [\n {\n name = \"example-target-pool\"\n target_port = 80\n targets = [\n {\n display_name = stackit_server.boot-from-image.name\n ip = stackit_network_interface.nic.ipv4\n }\n ]\n active_health_check = {\n healthy_threshold = 10\n interval = \"3s\"\n interval_jitter = \"3s\"\n timeout = \"3s\"\n unhealthy_threshold = 10\n }\n }\n ]\n listeners = [\n {\n display_name = \"example-listener\"\n port = 80\n protocol = \"PROTOCOL_TCP\"\n target_pool = \"example-target-pool\"\n }\n ]\n networks = [\n {\n network_id = stackit_network.example_network.network_id\n role = \"ROLE_LISTENERS_AND_TARGETS\"\n }\n ]\n external_address = stackit_public_ip.public-ip.ip\n options = {\n private_network_only = false\n }\n}\n```\n", + "properties": { + "externalAddress": { + "type": "string", + "description": "External Load Balancer IP address where this Load Balancer is exposed.\n" + }, + "listeners": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerListener:LoadbalancerListener" + }, + "description": "List of all listeners which will accept traffic. Limited to 20.\n" + }, + "name": { + "type": "string", + "description": "Load balancer name.\n" + }, + "networks": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerNetwork:LoadbalancerNetwork" + }, + "description": "List of networks that listeners and targets reside in.\n" + }, + "options": { + "$ref": "#/types/stackit:index/LoadbalancerOptions:LoadbalancerOptions", + "description": "Defines any optional functionality you want to have enabled on your load balancer.\n" + }, + "privateAddress": { + "type": "string", + "description": "Transient private Load Balancer IP address. It can change any time.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the Load Balancer is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "targetPools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPool:LoadbalancerTargetPool" + }, + "description": "List of all target pools which will be used in the Load Balancer. Limited to 20.\n" + } + }, + "required": [ + "listeners", + "name", + "networks", + "options", + "privateAddress", + "projectId", + "region", + "targetPools" + ], + "inputProperties": { + "externalAddress": { + "type": "string", + "description": "External Load Balancer IP address where this Load Balancer is exposed.\n" + }, + "listeners": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerListener:LoadbalancerListener" + }, + "description": "List of all listeners which will accept traffic. Limited to 20.\n" + }, + "name": { + "type": "string", + "description": "Load balancer name.\n" + }, + "networks": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerNetwork:LoadbalancerNetwork" + }, + "description": "List of networks that listeners and targets reside in.\n" + }, + "options": { + "$ref": "#/types/stackit:index/LoadbalancerOptions:LoadbalancerOptions", + "description": "Defines any optional functionality you want to have enabled on your load balancer.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the Load Balancer is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "targetPools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPool:LoadbalancerTargetPool" + }, + "description": "List of all target pools which will be used in the Load Balancer. Limited to 20.\n" + } + }, + "requiredInputs": [ + "listeners", + "networks", + "projectId", + "targetPools" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Loadbalancer resources.\n", + "properties": { + "externalAddress": { + "type": "string", + "description": "External Load Balancer IP address where this Load Balancer is exposed.\n" + }, + "listeners": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerListener:LoadbalancerListener" + }, + "description": "List of all listeners which will accept traffic. Limited to 20.\n" + }, + "name": { + "type": "string", + "description": "Load balancer name.\n" + }, + "networks": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerNetwork:LoadbalancerNetwork" + }, + "description": "List of networks that listeners and targets reside in.\n" + }, + "options": { + "$ref": "#/types/stackit:index/LoadbalancerOptions:LoadbalancerOptions", + "description": "Defines any optional functionality you want to have enabled on your load balancer.\n" + }, + "privateAddress": { + "type": "string", + "description": "Transient private Load Balancer IP address. It can change any time.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the Load Balancer is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "targetPools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/LoadbalancerTargetPool:LoadbalancerTargetPool" + }, + "description": "List of all target pools which will be used in the Load Balancer. Limited to 20.\n" + } + }, + "type": "object" + } + }, + "stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential": { + "description": "Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into\n\n## Example Usage\n\n```terraform\nresource \"stackit_loadbalancer_observability_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n display_name = \"example-credentials\"\n username = \"example-user\"\n password = \"example-password\"\n}\n```\n", + "properties": { + "credentialsRef": { + "type": "string", + "description": "The credentials reference is used by the Load Balancer to define which credentials it will use.\n" + }, + "displayName": { + "type": "string", + "description": "Observability credential name.\n" + }, + "password": { + "type": "string", + "description": "The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the load balancer observability credential is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "username": { + "type": "string", + "description": "The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + } + }, + "required": [ + "credentialsRef", + "displayName", + "password", + "projectId", + "region", + "username" + ], + "inputProperties": { + "displayName": { + "type": "string", + "description": "Observability credential name.\n" + }, + "password": { + "type": "string", + "description": "The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the load balancer observability credential is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "username": { + "type": "string", + "description": "The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + } + }, + "requiredInputs": [ + "displayName", + "password", + "projectId", + "username" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering LoadbalancerObservabilityCredential resources.\n", + "properties": { + "credentialsRef": { + "type": "string", + "description": "The credentials reference is used by the Load Balancer to define which credentials it will use.\n" + }, + "displayName": { + "type": "string", + "description": "Observability credential name.\n" + }, + "password": { + "type": "string", + "description": "The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the load balancer observability credential is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "username": { + "type": "string", + "description": "The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into.\n" + } + }, + "type": "object" + } + }, + "stackit:index/logmeCredential:LogmeCredential": { + "description": "LogMe credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_logme_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "required": [ + "credentialId", + "host", + "instanceId", + "password", + "port", + "projectId", + "uri", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering LogmeCredential resources.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/logmeInstance:LogmeInstance": { + "description": "LogMe instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_logme_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n version = \"2\"\n plan_name = \"stackit-logme2-1.2.50-replica\"\n parameters = {\n sgw_acl = \"193.148.160.0/19,45.129.40.0/21,45.135.244.0/22\"\n }\n}\n```\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/LogmeInstanceParameters:LogmeInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/LogmeInstanceParameters:LogmeInstanceParameters" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering LogmeInstance resources.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/LogmeInstanceParameters:LogmeInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object" + } + }, + "stackit:index/mariadbCredential:MariadbCredential": { + "description": "MariaDB credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_mariadb_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "required": [ + "credentialId", + "host", + "hosts", + "instanceId", + "name", + "password", + "port", + "projectId", + "uri", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering MariadbCredential resources.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/mariadbInstance:MariadbInstance": { + "description": "MariaDB instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_mariadb_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n version = \"10.11\"\n plan_name = \"stackit-mariadb-1.2.10-replica\"\n parameters = {\n sgw_acl = \"193.148.160.0/19,45.129.40.0/21,45.135.244.0/22\"\n }\n}\n```\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/MariadbInstanceParameters:MariadbInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/MariadbInstanceParameters:MariadbInstanceParameters" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering MariadbInstance resources.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/MariadbInstanceParameters:MariadbInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object" + } + }, + "stackit:index/modelservingToken:ModelservingToken": { + "description": "AI Model Serving Auth Token Resource schema.\n\n## Example Usage\n\n### Automatically rotate AI model serving token\n```terraform\nresource \"time_rotating\" \"rotate\" {\n rotation_days = 80\n}\n\nresource \"stackit_modelserving_token\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"Example token\"\n \n rotate_when_changed = {\n rotation = time_rotating.rotate.id\n }\n\n}\n```\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the AI model serving auth token.\n" + }, + "name": { + "type": "string", + "description": "Name of the AI model serving auth token.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the AI model serving auth token is associated.\n" + }, + "region": { + "type": "string", + "description": "Region to which the AI model serving auth token is associated. If not defined, the provider region is used\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "state": { + "type": "string", + "description": "State of the AI model serving auth token.\n" + }, + "token": { + "type": "string", + "description": "Content of the AI model serving auth token.\n", + "secret": true + }, + "tokenId": { + "type": "string", + "description": "The AI model serving auth token ID.\n" + }, + "ttlDuration": { + "type": "string", + "description": "The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s\n" + }, + "validUntil": { + "type": "string", + "description": "The time until the AI model serving auth token is valid.\n" + } + }, + "required": [ + "name", + "projectId", + "region", + "state", + "token", + "tokenId", + "validUntil" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "The description of the AI model serving auth token.\n" + }, + "name": { + "type": "string", + "description": "Name of the AI model serving auth token.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the AI model serving auth token is associated.\n" + }, + "region": { + "type": "string", + "description": "Region to which the AI model serving auth token is associated. If not defined, the provider region is used\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "ttlDuration": { + "type": "string", + "description": "The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ModelservingToken resources.\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the AI model serving auth token.\n" + }, + "name": { + "type": "string", + "description": "Name of the AI model serving auth token.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the AI model serving auth token is associated.\n" + }, + "region": { + "type": "string", + "description": "Region to which the AI model serving auth token is associated. If not defined, the provider region is used\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "state": { + "type": "string", + "description": "State of the AI model serving auth token.\n" + }, + "token": { + "type": "string", + "description": "Content of the AI model serving auth token.\n", + "secret": true + }, + "tokenId": { + "type": "string", + "description": "The AI model serving auth token ID.\n" + }, + "ttlDuration": { + "type": "string", + "description": "The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s\n" + }, + "validUntil": { + "type": "string", + "description": "The time until the AI model serving auth token is valid.\n" + } + }, + "type": "object" + } + }, + "stackit:index/mongodbflexInstance:MongodbflexInstance": { + "description": "MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_mongodbflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n acl = [\"XXX.XXX.XXX.X/XX\", \"XX.XXX.XX.X/XX\"]\n flavor = {\n cpu = 1\n ram = 4\n }\n replicas = 1\n storage = {\n class = \"class\"\n size = 10\n }\n version = \"7.0\"\n options = {\n type = \"Single\"\n snapshot_retention_days = 3\n point_in_time_window_hours = 30\n }\n backup_schedule = \"0 0 * * *\"\n}\n```\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the MongoDB Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\").\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/MongodbflexInstanceFlavor:MongodbflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/MongodbflexInstanceOptions:MongodbflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/MongodbflexInstanceStorage:MongodbflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "required": [ + "acls", + "backupSchedule", + "flavor", + "instanceId", + "name", + "options", + "projectId", + "replicas", + "storage", + "version" + ], + "inputProperties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the MongoDB Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\").\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/MongodbflexInstanceFlavor:MongodbflexInstanceFlavor" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/MongodbflexInstanceOptions:MongodbflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/MongodbflexInstanceStorage:MongodbflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "requiredInputs": [ + "acls", + "backupSchedule", + "flavor", + "options", + "projectId", + "replicas", + "storage", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering MongodbflexInstance resources.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the MongoDB Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\").\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/MongodbflexInstanceFlavor:MongodbflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/MongodbflexInstanceOptions:MongodbflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/MongodbflexInstanceStorage:MongodbflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/mongodbflexUser:MongodbflexUser": { + "description": "MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_mongodbflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n username = \"username\"\n roles = [\"role\"]\n database = \"database\"\n}\n```\n", + "properties": { + "database": { + "type": "string" + }, + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`]\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "required": [ + "database", + "host", + "instanceId", + "password", + "port", + "projectId", + "roles", + "uri", + "userId", + "username" + ], + "inputProperties": { + "database": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`]\n" + }, + "username": { + "type": "string" + } + }, + "requiredInputs": [ + "database", + "instanceId", + "projectId", + "roles" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering MongodbflexUser resources.\n", + "properties": { + "database": { + "type": "string" + }, + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`]\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/network:Network": { + "description": "Network resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_network\" \"example_with_name\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-with-name\"\n}\n\nresource \"stackit_network\" \"example_routed_network\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-routed-network\"\n labels = {\n \"key\" = \"value\"\n }\n routed = true\n}\n\nresource \"stackit_network\" \"example_non_routed_network\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-non-routed-network\"\n ipv4_nameservers = [\"1.2.3.4\", \"5.6.7.8\"]\n ipv4_prefix_length = 24\n ipv4_gateway = \"10.1.2.3\"\n ipv4_prefix = \"10.1.2.0/24\"\n labels = {\n \"key\" = \"value\"\n }\n routed = false\n}\n```\n", + "properties": { + "ipv4Gateway": { + "type": "string", + "description": "The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv4Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 nameservers of the network.\n" + }, + "ipv4Prefix": { + "type": "string", + "description": "The IPv4 prefix of the network (CIDR).\n" + }, + "ipv4PrefixLength": { + "type": "integer", + "description": "The IPv4 prefix length of the network.\n" + }, + "ipv4Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 prefixes of the network.\n" + }, + "ipv6Gateway": { + "type": "string", + "description": "The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv6Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 nameservers of the network.\n" + }, + "ipv6Prefix": { + "type": "string", + "description": "The IPv6 prefix of the network (CIDR).\n" + }, + "ipv6PrefixLength": { + "type": "integer", + "description": "The IPv6 prefix length of the network.\n" + }, + "ipv6Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 prefixes of the network.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the network.\n" + }, + "nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4.\n", + "deprecationMessage": "Use `ipv4_nameservers` to configure the nameservers for IPv4." + }, + "networkId": { + "type": "string", + "description": "The network ID.\n" + }, + "noIpv4Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "noIpv6Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks.\n", + "deprecationMessage": "Use `ipv4_prefixes` to read the prefixes of the IPv4 networks." + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "publicIp": { + "type": "string", + "description": "The public IP of the network.\n" + }, + "routed": { + "type": "boolean", + "description": "If set to `true`, the network is routed and therefore accessible from other networks.\n" + } + }, + "required": [ + "ipv4Gateway", + "ipv4Nameservers", + "ipv4Prefix", + "ipv4PrefixLength", + "ipv4Prefixes", + "ipv6Gateway", + "ipv6Nameservers", + "ipv6Prefixes", + "name", + "nameservers", + "networkId", + "prefixes", + "projectId", + "publicIp", + "routed" + ], + "inputProperties": { + "ipv4Gateway": { + "type": "string", + "description": "The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv4Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 nameservers of the network.\n" + }, + "ipv4Prefix": { + "type": "string", + "description": "The IPv4 prefix of the network (CIDR).\n" + }, + "ipv4PrefixLength": { + "type": "integer", + "description": "The IPv4 prefix length of the network.\n" + }, + "ipv6Gateway": { + "type": "string", + "description": "The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv6Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 nameservers of the network.\n" + }, + "ipv6Prefix": { + "type": "string", + "description": "The IPv6 prefix of the network (CIDR).\n" + }, + "ipv6PrefixLength": { + "type": "integer", + "description": "The IPv6 prefix length of the network.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the network.\n" + }, + "nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4.\n", + "deprecationMessage": "Use `ipv4_nameservers` to configure the nameservers for IPv4." + }, + "noIpv4Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "noIpv6Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "routed": { + "type": "boolean", + "description": "If set to `true`, the network is routed and therefore accessible from other networks.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Network resources.\n", + "properties": { + "ipv4Gateway": { + "type": "string", + "description": "The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv4Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 nameservers of the network.\n" + }, + "ipv4Prefix": { + "type": "string", + "description": "The IPv4 prefix of the network (CIDR).\n" + }, + "ipv4PrefixLength": { + "type": "integer", + "description": "The IPv4 prefix length of the network.\n" + }, + "ipv4Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 prefixes of the network.\n" + }, + "ipv6Gateway": { + "type": "string", + "description": "The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv6Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 nameservers of the network.\n" + }, + "ipv6Prefix": { + "type": "string", + "description": "The IPv6 prefix of the network (CIDR).\n" + }, + "ipv6PrefixLength": { + "type": "integer", + "description": "The IPv6 prefix length of the network.\n" + }, + "ipv6Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 prefixes of the network.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the network.\n" + }, + "nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4.\n", + "deprecationMessage": "Use `ipv4_nameservers` to configure the nameservers for IPv4." + }, + "networkId": { + "type": "string", + "description": "The network ID.\n" + }, + "noIpv4Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "noIpv6Gateway": { + "type": "boolean", + "description": "If set to `true`, the network doesn't have a gateway.\n" + }, + "prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks.\n", + "deprecationMessage": "Use `ipv4_prefixes` to read the prefixes of the IPv4 networks." + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "publicIp": { + "type": "string", + "description": "The public IP of the network.\n" + }, + "routed": { + "type": "boolean", + "description": "If set to `true`, the network is routed and therefore accessible from other networks.\n" + } + }, + "type": "object" + } + }, + "stackit:index/networkArea:NetworkArea": { + "description": "Network area resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_network_area\" \"example\" {\n organization_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-network-area\"\n network_ranges = [\n {\n prefix = \"192.168.0.0/24\"\n }\n ]\n transfer_network = \"192.168.0.0/24\"\n labels = {\n \"key\" = \"value\"\n }\n}\n```\n", + "properties": { + "defaultNameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of DNS Servers/Nameservers.\n" + }, + "defaultPrefixLength": { + "type": "integer", + "description": "The default prefix length for networks in the network area.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "maxPrefixLength": { + "type": "integer", + "description": "The maximal prefix length for networks in the network area.\n" + }, + "minPrefixLength": { + "type": "integer", + "description": "The minimal prefix length for networks in the network area.\n" + }, + "name": { + "type": "string", + "description": "The name of the network area.\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID.\n" + }, + "networkRanges": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/NetworkAreaNetworkRange:NetworkAreaNetworkRange" + }, + "description": "List of Network ranges.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "projectCount": { + "type": "integer", + "description": "The amount of projects currently referencing this area.\n" + }, + "transferNetwork": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR).\n" + } + }, + "required": [ + "defaultPrefixLength", + "maxPrefixLength", + "minPrefixLength", + "name", + "networkAreaId", + "networkRanges", + "organizationId", + "projectCount", + "transferNetwork" + ], + "inputProperties": { + "defaultNameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of DNS Servers/Nameservers.\n" + }, + "defaultPrefixLength": { + "type": "integer", + "description": "The default prefix length for networks in the network area.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "maxPrefixLength": { + "type": "integer", + "description": "The maximal prefix length for networks in the network area.\n" + }, + "minPrefixLength": { + "type": "integer", + "description": "The minimal prefix length for networks in the network area.\n" + }, + "name": { + "type": "string", + "description": "The name of the network area.\n" + }, + "networkRanges": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/NetworkAreaNetworkRange:NetworkAreaNetworkRange" + }, + "description": "List of Network ranges.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "transferNetwork": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR).\n" + } + }, + "requiredInputs": [ + "networkRanges", + "organizationId", + "transferNetwork" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering NetworkArea resources.\n", + "properties": { + "defaultNameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of DNS Servers/Nameservers.\n" + }, + "defaultPrefixLength": { + "type": "integer", + "description": "The default prefix length for networks in the network area.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "maxPrefixLength": { + "type": "integer", + "description": "The maximal prefix length for networks in the network area.\n" + }, + "minPrefixLength": { + "type": "integer", + "description": "The minimal prefix length for networks in the network area.\n" + }, + "name": { + "type": "string", + "description": "The name of the network area.\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID.\n" + }, + "networkRanges": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/NetworkAreaNetworkRange:NetworkAreaNetworkRange" + }, + "description": "List of Network ranges.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "projectCount": { + "type": "integer", + "description": "The amount of projects currently referencing this area.\n" + }, + "transferNetwork": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR).\n" + } + }, + "type": "object" + } + }, + "stackit:index/networkAreaRoute:NetworkAreaRoute": { + "description": "Network area route resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_network_area_route\" \"example\" {\n organization_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_area_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n prefix = \"192.168.0.0/24\"\n next_hop = \"192.168.0.0\"\n labels = {\n \"key\" = \"value\"\n }\n}\n```\n", + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID to which the network area route is associated.\n" + }, + "networkAreaRouteId": { + "type": "string", + "description": "The network area route ID.\n" + }, + "nextHop": { + "type": "string", + "description": "The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "prefix": { + "type": "string", + "description": "The network, that is reachable though the Next Hop. Should use CIDR notation.\n" + } + }, + "required": [ + "networkAreaId", + "networkAreaRouteId", + "nextHop", + "organizationId", + "prefix" + ], + "inputProperties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID to which the network area route is associated.\n" + }, + "nextHop": { + "type": "string", + "description": "The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "prefix": { + "type": "string", + "description": "The network, that is reachable though the Next Hop. Should use CIDR notation.\n" + } + }, + "requiredInputs": [ + "networkAreaId", + "nextHop", + "organizationId", + "prefix" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering NetworkAreaRoute resources.\n", + "properties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID to which the network area route is associated.\n" + }, + "networkAreaRouteId": { + "type": "string", + "description": "The network area route ID.\n" + }, + "nextHop": { + "type": "string", + "description": "The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "prefix": { + "type": "string", + "description": "The network, that is reachable though the Next Hop. Should use CIDR notation.\n" + } + }, + "type": "object" + } + }, + "stackit:index/networkInterface:NetworkInterface": { + "description": "Network interface resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_network_interface\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n allowed_addresses = [\"192.168.0.0/24\"]\n security_group_ids = [\"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"]\n}\n```\n", + "properties": { + "allowedAddresses": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of CIDR (Classless Inter-Domain Routing) notations.\n" + }, + "device": { + "type": "string", + "description": "The device UUID of the network interface.\n" + }, + "ipv4": { + "type": "string", + "description": "The IPv4 address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a network interface.\n" + }, + "mac": { + "type": "string", + "description": "The MAC address of network interface.\n" + }, + "name": { + "type": "string", + "description": "The name of the network interface.\n" + }, + "networkId": { + "type": "string", + "description": "The network ID to which the network interface is associated.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "security": { + "type": "boolean", + "description": "The Network Interface Security. If set to false, then no security groups will apply to this network interface.\n" + }, + "securityGroupIds": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of security group UUIDs. If security is set to false, setting this field will lead to an error.\n" + }, + "type": { + "type": "string", + "description": "Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`.\n" + } + }, + "required": [ + "allowedAddresses", + "device", + "ipv4", + "mac", + "name", + "networkId", + "networkInterfaceId", + "projectId", + "security", + "securityGroupIds", + "type" + ], + "inputProperties": { + "allowedAddresses": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of CIDR (Classless Inter-Domain Routing) notations.\n" + }, + "ipv4": { + "type": "string", + "description": "The IPv4 address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a network interface.\n" + }, + "name": { + "type": "string", + "description": "The name of the network interface.\n" + }, + "networkId": { + "type": "string", + "description": "The network ID to which the network interface is associated.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "security": { + "type": "boolean", + "description": "The Network Interface Security. If set to false, then no security groups will apply to this network interface.\n" + }, + "securityGroupIds": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of security group UUIDs. If security is set to false, setting this field will lead to an error.\n" + } + }, + "requiredInputs": [ + "networkId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering NetworkInterface resources.\n", + "properties": { + "allowedAddresses": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of CIDR (Classless Inter-Domain Routing) notations.\n" + }, + "device": { + "type": "string", + "description": "The device UUID of the network interface.\n" + }, + "ipv4": { + "type": "string", + "description": "The IPv4 address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a network interface.\n" + }, + "mac": { + "type": "string", + "description": "The MAC address of network interface.\n" + }, + "name": { + "type": "string", + "description": "The name of the network interface.\n" + }, + "networkId": { + "type": "string", + "description": "The network ID to which the network interface is associated.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "security": { + "type": "boolean", + "description": "The Network Interface Security. If set to false, then no security groups will apply to this network interface.\n" + }, + "securityGroupIds": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of security group UUIDs. If security is set to false, setting this field will lead to an error.\n" + }, + "type": { + "type": "string", + "description": "Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`.\n" + } + }, + "type": "object" + } + }, + "stackit:index/objectstorageBucket:ObjectstorageBucket": { + "description": "ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background.\n\n## Example Usage\n\n```terraform\nresource \"stackit_objectstorage_bucket\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-bucket\"\n}\n```\n", + "properties": { + "name": { + "type": "string", + "description": "The bucket name. It must be DNS conform.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the bucket is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urlPathStyle": { + "type": "string" + }, + "urlVirtualHostedStyle": { + "type": "string" + } + }, + "required": [ + "name", + "projectId", + "region", + "urlPathStyle", + "urlVirtualHostedStyle" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "The bucket name. It must be DNS conform.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the bucket is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObjectstorageBucket resources.\n", + "properties": { + "name": { + "type": "string", + "description": "The bucket name. It must be DNS conform.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the bucket is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urlPathStyle": { + "type": "string" + }, + "urlVirtualHostedStyle": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/objectstorageCredential:ObjectstorageCredential": { + "description": "ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_objectstorage_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credentials_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n expiration_timestamp = \"2027-01-02T03:04:05Z\"\n}\n```\n", + "properties": { + "accessKey": { + "type": "string" + }, + "credentialId": { + "type": "string", + "description": "The credential ID.\n" + }, + "credentialsGroupId": { + "type": "string", + "description": "The credential group ID.\n" + }, + "expirationTimestamp": { + "type": "string", + "description": "Expiration timestamp, in RFC339 format without fractional seconds. Example: \"2025-01-01T00:00:00Z\". If not set, the credential never expires.\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the credential group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "secretAccessKey": { + "type": "string", + "secret": true + } + }, + "required": [ + "accessKey", + "credentialId", + "credentialsGroupId", + "expirationTimestamp", + "name", + "projectId", + "region", + "secretAccessKey" + ], + "inputProperties": { + "credentialsGroupId": { + "type": "string", + "description": "The credential group ID.\n" + }, + "expirationTimestamp": { + "type": "string", + "description": "Expiration timestamp, in RFC339 format without fractional seconds. Example: \"2025-01-01T00:00:00Z\". If not set, the credential never expires.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the credential group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "requiredInputs": [ + "credentialsGroupId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObjectstorageCredential resources.\n", + "properties": { + "accessKey": { + "type": "string" + }, + "credentialId": { + "type": "string", + "description": "The credential ID.\n" + }, + "credentialsGroupId": { + "type": "string", + "description": "The credential group ID.\n" + }, + "expirationTimestamp": { + "type": "string", + "description": "Expiration timestamp, in RFC339 format without fractional seconds. Example: \"2025-01-01T00:00:00Z\". If not set, the credential never expires.\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the credential group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "secretAccessKey": { + "type": "string", + "secret": true + } + }, + "type": "object" + } + }, + "stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup": { + "description": "ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background.\n\n## Example Usage\n\n```terraform\nresource \"stackit_objectstorage_credentials_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-credentials-group\"\n}\n```\n", + "properties": { + "credentialsGroupId": { + "type": "string", + "description": "The credentials group ID\n" + }, + "name": { + "type": "string", + "description": "The credentials group's display name.\n" + }, + "projectId": { + "type": "string", + "description": "Project ID to which the credentials group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urn": { + "type": "string", + "description": "Credentials group uniform resource name (URN)\n" + } + }, + "required": [ + "credentialsGroupId", + "name", + "projectId", + "region", + "urn" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "The credentials group's display name.\n" + }, + "projectId": { + "type": "string", + "description": "Project ID to which the credentials group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObjectstorageCredentialsGroup resources.\n", + "properties": { + "credentialsGroupId": { + "type": "string", + "description": "The credentials group ID\n" + }, + "name": { + "type": "string", + "description": "The credentials group's display name.\n" + }, + "projectId": { + "type": "string", + "description": "Project ID to which the credentials group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urn": { + "type": "string", + "description": "Credentials group uniform resource name (URN)\n" + } + }, + "type": "object" + } + }, + "stackit:index/observabilityAlertgroup:ObservabilityAlertgroup": { + "description": "Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_observability_alertgroup\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-alert-group\"\n interval = \"60s\"\n rules = [\n {\n alert = \"example-alert-name\"\n expression = \"kube_node_status_condition{condition=\\\"Ready\\\", status=\\\"false\\\"} \u003e 0\"\n for = \"60s\"\n labels = {\n severity = \"critical\"\n },\n annotations = {\n summary : \"example summary\"\n description : \"example description\"\n }\n },\n {\n alert = \"example-alert-name-2\"\n expression = \"kube_node_status_condition{condition=\\\"Ready\\\", status=\\\"false\\\"} \u003e 0\"\n for = \"1m\"\n labels = {\n severity = \"critical\"\n },\n annotations = {\n summary : \"example summary\"\n description : \"example description\"\n }\n },\n ]\n}\n```\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityAlertgroupRule:ObservabilityAlertgroupRule" + }, + "description": "Rules for the alert group\n" + } + }, + "required": [ + "instanceId", + "interval", + "name", + "projectId", + "rules" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityAlertgroupRule:ObservabilityAlertgroupRule" + }, + "description": "Rules for the alert group\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId", + "rules" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObservabilityAlertgroup resources.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityAlertgroupRule:ObservabilityAlertgroupRule" + }, + "description": "Rules for the alert group\n" + } + }, + "type": "object" + } + }, + "stackit:index/observabilityCredential:ObservabilityCredential": { + "description": "Observability credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_observability_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "instanceId": { + "type": "string", + "description": "The Observability Instance ID the credential belongs to.\n" + }, + "password": { + "type": "string", + "description": "Credential password\n", + "secret": true + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the credential is associated.\n" + }, + "username": { + "type": "string", + "description": "Credential username\n" + } + }, + "required": [ + "instanceId", + "password", + "projectId", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "The Observability Instance ID the credential belongs to.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the credential is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObservabilityCredential resources.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "The Observability Instance ID the credential belongs to.\n" + }, + "password": { + "type": "string", + "description": "Credential password\n", + "secret": true + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the credential is associated.\n" + }, + "username": { + "type": "string", + "description": "Credential username\n" + } + }, + "type": "object" + } + }, + "stackit:index/observabilityInstance:ObservabilityInstance": { + "description": "Observability instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_observability_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n plan_name = \"Observability-Monitoring-Medium-EU01\"\n acl = [\"1.1.1.1/32\", \"2.2.2.2/32\"]\n metrics_retention_days = 30\n metrics_retention_days_5m_downsampling = 10\n metrics_retention_days_1h_downsampling = 5\n}\n```\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation.\n" + }, + "alertConfig": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfig:ObservabilityInstanceAlertConfig", + "description": "Alert configuration for the instance.\n" + }, + "alertingUrl": { + "type": "string", + "description": "Specifies Alerting URL.\n" + }, + "dashboardUrl": { + "type": "string", + "description": "Specifies Observability instance dashboard URL.\n" + }, + "grafanaInitialAdminPassword": { + "type": "string", + "description": "Specifies an initial Grafana admin password.\n", + "secret": true + }, + "grafanaInitialAdminUser": { + "type": "string", + "description": "Specifies an initial Grafana admin username.\n" + }, + "grafanaPublicReadAccess": { + "type": "boolean", + "description": "If true, anyone can access Grafana dashboards without logging in.\n" + }, + "grafanaUrl": { + "type": "string", + "description": "Specifies Grafana URL.\n" + }, + "instanceId": { + "type": "string", + "description": "The Observability instance ID.\n" + }, + "isUpdatable": { + "type": "boolean", + "description": "Specifies if the instance can be updated.\n" + }, + "jaegerTracesUrl": { + "type": "string" + }, + "jaegerUiUrl": { + "type": "string" + }, + "logsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing logs.\n" + }, + "logsUrl": { + "type": "string", + "description": "Specifies Logs URL.\n" + }, + "metricsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing metrics.\n" + }, + "metricsRetentionDays": { + "type": "integer", + "description": "Specifies for how many days the raw metrics are kept.\n" + }, + "metricsRetentionDays1hDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled).\n" + }, + "metricsRetentionDays5mDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled).\n" + }, + "metricsUrl": { + "type": "string", + "description": "Specifies metrics URL.\n" + }, + "name": { + "type": "string", + "description": "The name of the Observability instance.\n" + }, + "otlpTracesUrl": { + "type": "string" + }, + "parameters": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional parameters.\n" + }, + "planId": { + "type": "string", + "description": "The Observability plan ID.\n" + }, + "planName": { + "type": "string", + "description": "Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "targetsUrl": { + "type": "string", + "description": "Specifies Targets URL.\n" + }, + "zipkinSpansUrl": { + "type": "string" + } + }, + "required": [ + "alertingUrl", + "dashboardUrl", + "grafanaInitialAdminPassword", + "grafanaInitialAdminUser", + "grafanaPublicReadAccess", + "grafanaUrl", + "instanceId", + "isUpdatable", + "jaegerTracesUrl", + "jaegerUiUrl", + "logsPushUrl", + "logsUrl", + "metricsPushUrl", + "metricsRetentionDays", + "metricsRetentionDays1hDownsampling", + "metricsRetentionDays5mDownsampling", + "metricsUrl", + "name", + "otlpTracesUrl", + "parameters", + "planId", + "planName", + "projectId", + "targetsUrl", + "zipkinSpansUrl" + ], + "inputProperties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation.\n" + }, + "alertConfig": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfig:ObservabilityInstanceAlertConfig", + "description": "Alert configuration for the instance.\n" + }, + "metricsRetentionDays": { + "type": "integer", + "description": "Specifies for how many days the raw metrics are kept.\n" + }, + "metricsRetentionDays1hDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled).\n" + }, + "metricsRetentionDays5mDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled).\n" + }, + "name": { + "type": "string", + "description": "The name of the Observability instance.\n" + }, + "parameters": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional parameters.\n" + }, + "planName": { + "type": "string", + "description": "Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObservabilityInstance resources.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation.\n" + }, + "alertConfig": { + "$ref": "#/types/stackit:index/ObservabilityInstanceAlertConfig:ObservabilityInstanceAlertConfig", + "description": "Alert configuration for the instance.\n" + }, + "alertingUrl": { + "type": "string", + "description": "Specifies Alerting URL.\n" + }, + "dashboardUrl": { + "type": "string", + "description": "Specifies Observability instance dashboard URL.\n" + }, + "grafanaInitialAdminPassword": { + "type": "string", + "description": "Specifies an initial Grafana admin password.\n", + "secret": true + }, + "grafanaInitialAdminUser": { + "type": "string", + "description": "Specifies an initial Grafana admin username.\n" + }, + "grafanaPublicReadAccess": { + "type": "boolean", + "description": "If true, anyone can access Grafana dashboards without logging in.\n" + }, + "grafanaUrl": { + "type": "string", + "description": "Specifies Grafana URL.\n" + }, + "instanceId": { + "type": "string", + "description": "The Observability instance ID.\n" + }, + "isUpdatable": { + "type": "boolean", + "description": "Specifies if the instance can be updated.\n" + }, + "jaegerTracesUrl": { + "type": "string" + }, + "jaegerUiUrl": { + "type": "string" + }, + "logsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing logs.\n" + }, + "logsUrl": { + "type": "string", + "description": "Specifies Logs URL.\n" + }, + "metricsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing metrics.\n" + }, + "metricsRetentionDays": { + "type": "integer", + "description": "Specifies for how many days the raw metrics are kept.\n" + }, + "metricsRetentionDays1hDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled).\n" + }, + "metricsRetentionDays5mDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled).\n" + }, + "metricsUrl": { + "type": "string", + "description": "Specifies metrics URL.\n" + }, + "name": { + "type": "string", + "description": "The name of the Observability instance.\n" + }, + "otlpTracesUrl": { + "type": "string" + }, + "parameters": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional parameters.\n" + }, + "planId": { + "type": "string", + "description": "The Observability plan ID.\n" + }, + "planName": { + "type": "string", + "description": "Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "targetsUrl": { + "type": "string", + "description": "Specifies Targets URL.\n" + }, + "zipkinSpansUrl": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup": { + "description": "Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_observability_logalertgroup\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-log-alert-group\"\n interval = \"60m\"\n rules = [\n {\n alert = \"example-log-alert-name\"\n expression = \"sum(rate({namespace=\\\"example\\\", pod=\\\"logger\\\"} |= \\\"Simulated error message\\\" [1m])) \u003e 0\"\n for = \"60s\"\n labels = {\n severity = \"critical\"\n },\n annotations = {\n summary : \"example summary\"\n description : \"example description\"\n }\n },\n {\n alert = \"example-log-alert-name-2\"\n expression = \"sum(rate({namespace=\\\"example\\\", pod=\\\"logger\\\"} |= \\\"Another error message\\\" [1m])) \u003e 0\"\n for = \"60s\"\n labels = {\n severity = \"critical\"\n },\n annotations = {\n summary : \"example summary\"\n description : \"example description\"\n }\n },\n ]\n}\n```\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the log alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the log alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the log alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityLogalertgroupRule:ObservabilityLogalertgroupRule" + }, + "description": "Rules for the log alert group\n" + } + }, + "required": [ + "instanceId", + "interval", + "name", + "projectId", + "rules" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the log alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the log alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the log alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityLogalertgroupRule:ObservabilityLogalertgroupRule" + }, + "description": "Rules for the log alert group\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId", + "rules" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObservabilityLogalertgroup resources.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the log alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the log alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the log alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityLogalertgroupRule:ObservabilityLogalertgroupRule" + }, + "description": "Rules for the log alert group\n" + } + }, + "type": "object" + } + }, + "stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig": { + "description": "Observability scrape config resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_observability_scrapeconfig\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-job\"\n metrics_path = \"/my-metrics\"\n saml2 = {\n enable_url_parameters = true\n }\n targets = [\n {\n urls = [\"url1\", \"urls2\"]\n labels = {\n \"url1\" = \"dev\"\n }\n }\n ]\n}\n```\n", + "properties": { + "basicAuth": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigBasicAuth:ObservabilityScrapeconfigBasicAuth", + "description": "A basic authentication block.\n" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the scraping job is associated.\n" + }, + "metricsPath": { + "type": "string", + "description": "Specifies the job scraping url path. E.g. `/metrics`.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the scraping job.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the scraping job is associated.\n" + }, + "saml2": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigSaml2:ObservabilityScrapeconfigSaml2", + "description": "A SAML2 configuration block.\n" + }, + "sampleLimit": { + "type": "integer", + "description": "Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`.\n" + }, + "scheme": { + "type": "string", + "description": "Specifies the http scheme. Defaults to `https`.\n" + }, + "scrapeInterval": { + "type": "string", + "description": "Specifies the scrape interval as duration string. Defaults to `5m`.\n" + }, + "scrapeTimeout": { + "type": "string", + "description": "Specifies the scrape timeout as duration string. Defaults to `2m`.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigTarget:ObservabilityScrapeconfigTarget" + }, + "description": "The targets list (specified by the static config).\n" + } + }, + "required": [ + "basicAuth", + "instanceId", + "metricsPath", + "name", + "projectId", + "saml2", + "sampleLimit", + "scheme", + "scrapeInterval", + "scrapeTimeout", + "targets" + ], + "inputProperties": { + "basicAuth": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigBasicAuth:ObservabilityScrapeconfigBasicAuth", + "description": "A basic authentication block.\n" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the scraping job is associated.\n" + }, + "metricsPath": { + "type": "string", + "description": "Specifies the job scraping url path. E.g. `/metrics`.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the scraping job.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the scraping job is associated.\n" + }, + "saml2": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigSaml2:ObservabilityScrapeconfigSaml2", + "description": "A SAML2 configuration block.\n" + }, + "sampleLimit": { + "type": "integer", + "description": "Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`.\n" + }, + "scheme": { + "type": "string", + "description": "Specifies the http scheme. Defaults to `https`.\n" + }, + "scrapeInterval": { + "type": "string", + "description": "Specifies the scrape interval as duration string. Defaults to `5m`.\n" + }, + "scrapeTimeout": { + "type": "string", + "description": "Specifies the scrape timeout as duration string. Defaults to `2m`.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigTarget:ObservabilityScrapeconfigTarget" + }, + "description": "The targets list (specified by the static config).\n" + } + }, + "requiredInputs": [ + "instanceId", + "metricsPath", + "projectId", + "targets" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ObservabilityScrapeconfig resources.\n", + "properties": { + "basicAuth": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigBasicAuth:ObservabilityScrapeconfigBasicAuth", + "description": "A basic authentication block.\n" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the scraping job is associated.\n" + }, + "metricsPath": { + "type": "string", + "description": "Specifies the job scraping url path. E.g. `/metrics`.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the scraping job.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the scraping job is associated.\n" + }, + "saml2": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigSaml2:ObservabilityScrapeconfigSaml2", + "description": "A SAML2 configuration block.\n" + }, + "sampleLimit": { + "type": "integer", + "description": "Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`.\n" + }, + "scheme": { + "type": "string", + "description": "Specifies the http scheme. Defaults to `https`.\n" + }, + "scrapeInterval": { + "type": "string", + "description": "Specifies the scrape interval as duration string. Defaults to `5m`.\n" + }, + "scrapeTimeout": { + "type": "string", + "description": "Specifies the scrape timeout as duration string. Defaults to `2m`.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/ObservabilityScrapeconfigTarget:ObservabilityScrapeconfigTarget" + }, + "description": "The targets list (specified by the static config).\n" + } + }, + "type": "object" + } + }, + "stackit:index/opensearchCredential:OpensearchCredential": { + "description": "OpenSearch credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_opensearch_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "scheme": { + "type": "string" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "required": [ + "credentialId", + "host", + "hosts", + "instanceId", + "password", + "port", + "projectId", + "scheme", + "uri", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering OpensearchCredential resources.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "scheme": { + "type": "string" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/opensearchInstance:OpensearchInstance": { + "description": "OpenSearch instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_opensearch_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n version = \"2\"\n plan_name = \"stackit-opensearch-1.2.10-replica\"\n parameters = {\n sgw_acl = \"193.148.160.0/19,45.129.40.0/21,45.135.244.0/22\"\n }\n}\n```\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/OpensearchInstanceParameters:OpensearchInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/OpensearchInstanceParameters:OpensearchInstanceParameters" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering OpensearchInstance resources.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/OpensearchInstanceParameters:OpensearchInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object" + } + }, + "stackit:index/postgresflexDatabase:PostgresflexDatabase": { + "description": "Postgres Flex database resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_postgresflex_database\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"mydb\"\n owner = \"myusername\"\n}\n```\n", + "properties": { + "databaseId": { + "type": "string", + "description": "Database ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Postgres Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Database name.\n" + }, + "owner": { + "type": "string", + "description": "Username of the database owner.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "required": [ + "databaseId", + "instanceId", + "name", + "owner", + "projectId", + "region" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the Postgres Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Database name.\n" + }, + "owner": { + "type": "string", + "description": "Username of the database owner.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "requiredInputs": [ + "instanceId", + "owner", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering PostgresflexDatabase resources.\n", + "properties": { + "databaseId": { + "type": "string", + "description": "Database ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Postgres Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Database name.\n" + }, + "owner": { + "type": "string", + "description": "Username of the database owner.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object" + } + }, + "stackit:index/postgresflexInstance:PostgresflexInstance": { + "description": "Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_postgresflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n acl = [\"XXX.XXX.XXX.X/XX\", \"XX.XXX.XX.X/XX\"]\n backup_schedule = \"00 00 * * *\"\n flavor = {\n cpu = 2\n ram = 4\n }\n replicas = 3\n storage = {\n class = \"class\"\n size = 5\n }\n version = 14\n}\n```\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the PostgresFlex instance.\n" + }, + "backupSchedule": { + "type": "string" + }, + "flavor": { + "$ref": "#/types/stackit:index/PostgresflexInstanceFlavor:PostgresflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/PostgresflexInstanceStorage:PostgresflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "required": [ + "acls", + "backupSchedule", + "flavor", + "instanceId", + "name", + "projectId", + "region", + "replicas", + "storage", + "version" + ], + "inputProperties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the PostgresFlex instance.\n" + }, + "backupSchedule": { + "type": "string" + }, + "flavor": { + "$ref": "#/types/stackit:index/PostgresflexInstanceFlavor:PostgresflexInstanceFlavor" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/PostgresflexInstanceStorage:PostgresflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "requiredInputs": [ + "acls", + "backupSchedule", + "flavor", + "projectId", + "replicas", + "storage", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering PostgresflexInstance resources.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the PostgresFlex instance.\n" + }, + "backupSchedule": { + "type": "string" + }, + "flavor": { + "$ref": "#/types/stackit:index/PostgresflexInstanceFlavor:PostgresflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/PostgresflexInstanceStorage:PostgresflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/postgresflexUser:PostgresflexUser": { + "description": "Postgres Flex user resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_postgresflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n username = \"username\"\n roles = [\"role\"]\n}\n```\n", + "properties": { + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Supported values are: `login`, `createdb`.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "required": [ + "host", + "instanceId", + "password", + "port", + "projectId", + "region", + "roles", + "uri", + "userId", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Supported values are: `login`, `createdb`.\n" + }, + "username": { + "type": "string" + } + }, + "requiredInputs": [ + "instanceId", + "projectId", + "roles", + "username" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering PostgresflexUser resources.\n", + "properties": { + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. Supported values are: `login`, `createdb`.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/publicIp:PublicIp": { + "description": "Public IP resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_public_ip\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_interface_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n labels = {\n \"key\" = \"value\"\n }\n}\n```\n", + "properties": { + "ip": { + "type": "string", + "description": "The IP address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkInterfaceId": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "required": [ + "ip", + "networkInterfaceId", + "projectId", + "publicIpId" + ], + "inputProperties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkInterfaceId": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering PublicIp resources.\n", + "properties": { + "ip": { + "type": "string", + "description": "The IP address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkInterfaceId": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/publicIpAssociate:PublicIpAssociate": { + "description": "Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `stackit.PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration.\n\n!\u003e The `stackit.PublicIpAssociate` resource should not be used together with the `stackit.PublicIp` resource for the same public IP or for the same network interface. \nUsing both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association.\n\n## Example Usage\n\n```terraform\nresource \"stackit_public_ip_associate\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n public_ip_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_interface_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "ip": { + "type": "string", + "description": "The IP address.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The ID of the network interface (or virtual IP) to which the public IP should be attached to.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "required": [ + "ip", + "networkInterfaceId", + "projectId", + "publicIpId" + ], + "inputProperties": { + "networkInterfaceId": { + "type": "string", + "description": "The ID of the network interface (or virtual IP) to which the public IP should be attached to.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "requiredInputs": [ + "networkInterfaceId", + "projectId", + "publicIpId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering PublicIpAssociate resources.\n", + "properties": { + "ip": { + "type": "string", + "description": "The IP address.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The ID of the network interface (or virtual IP) to which the public IP should be attached to.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/rabbitmqCredential:RabbitmqCredential": { + "description": "RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_rabbitmq_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "httpApiUri": { + "type": "string" + }, + "httpApiUris": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "management": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "username": { + "type": "string" + } + }, + "required": [ + "credentialId", + "host", + "hosts", + "httpApiUri", + "httpApiUris", + "instanceId", + "management", + "password", + "port", + "projectId", + "uri", + "uris", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering RabbitmqCredential resources.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "httpApiUri": { + "type": "string" + }, + "httpApiUris": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "management": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/rabbitmqInstance:RabbitmqInstance": { + "description": "RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_rabbitmq_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n version = \"3.13\"\n plan_name = \"stackit-rabbitmq-1.2.10-replica\"\n parameters = {\n sgw_acl = \"193.148.160.0/19,45.129.40.0/21,45.135.244.0/22\"\n consumer_timeout = 18000000\n enable_monitoring = false\n plugins = [\"rabbitmq_consistent_hash_exchange\", \"rabbitmq_federation\", \"rabbitmq_tracing\"]\n }\n}\n```\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RabbitmqInstanceParameters:RabbitmqInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RabbitmqInstanceParameters:RabbitmqInstanceParameters" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering RabbitmqInstance resources.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RabbitmqInstanceParameters:RabbitmqInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object" + } + }, + "stackit:index/redisCredential:RedisCredential": { + "description": "Redis credential resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_redis_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "loadBalancedHost": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "description": "Connection URI.\n", + "secret": true + }, + "username": { + "type": "string" + } + }, + "required": [ + "credentialId", + "host", + "hosts", + "instanceId", + "loadBalancedHost", + "password", + "port", + "projectId", + "uri", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering RedisCredential resources.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "loadBalancedHost": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "description": "Connection URI.\n", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/redisInstance:RedisInstance": { + "description": "Redis instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_redis_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n version = \"7\"\n plan_name = \"stackit-redis-1.2.10-replica\"\n parameters = {\n sgw_acl = \"193.148.160.0/19,45.129.40.0/21,45.135.244.0/22\"\n enable_monitoring = false\n down_after_milliseconds = 30000\n syslog = [\"logs4.your-syslog-endpoint.com:54321\"]\n }\n}\n```\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RedisInstanceParameters:RedisInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RedisInstanceParameters:RedisInstanceParameters" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "requiredInputs": [ + "planName", + "projectId", + "version" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering RedisInstance resources.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/RedisInstanceParameters:RedisInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object" + } + }, + "stackit:index/resourcemanagerProject:ResourcemanagerProject": { + "description": "## Example Usage\n\n```terraform\nresource \"stackit_resourcemanager_project\" \"example\" {\n parent_container_id = \"example-parent-container-abc123\"\n name = \"example-container\"\n labels = {\n \"Label 1\" = \"foo\"\n // \"networkArea\" = stackit_network_area.foo.network_area_id\n }\n owner_email = \"john.doe@stackit.cloud\"\n}\n```\n", + "properties": { + "containerId": { + "type": "string", + "description": "Project container ID. Globally unique, user-friendly identifier.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=\u003cnetworkAreaID\u003e` is required.\n" + }, + "name": { + "type": "string", + "description": "Project name.\n" + }, + "ownerEmail": { + "type": "string", + "description": "Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect.\n" + }, + "parentContainerId": { + "type": "string", + "description": "Parent resource identifier. Both container ID (user-friendly) and UUID are supported\n" + }, + "projectId": { + "type": "string", + "description": "Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project.\n" + } + }, + "required": [ + "containerId", + "name", + "ownerEmail", + "parentContainerId", + "projectId" + ], + "inputProperties": { + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=\u003cnetworkAreaID\u003e` is required.\n" + }, + "name": { + "type": "string", + "description": "Project name.\n" + }, + "ownerEmail": { + "type": "string", + "description": "Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect.\n" + }, + "parentContainerId": { + "type": "string", + "description": "Parent resource identifier. Both container ID (user-friendly) and UUID are supported\n" + } + }, + "requiredInputs": [ + "ownerEmail", + "parentContainerId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ResourcemanagerProject resources.\n", + "properties": { + "containerId": { + "type": "string", + "description": "Project container ID. Globally unique, user-friendly identifier.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=\u003cnetworkAreaID\u003e` is required.\n" + }, + "name": { + "type": "string", + "description": "Project name.\n" + }, + "ownerEmail": { + "type": "string", + "description": "Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect.\n" + }, + "parentContainerId": { + "type": "string", + "description": "Parent resource identifier. Both container ID (user-friendly) and UUID are supported\n" + }, + "projectId": { + "type": "string", + "description": "Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project.\n" + } + }, + "type": "object" + } + }, + "stackit:index/secretsmanagerInstance:SecretsmanagerInstance": { + "description": "Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_secretsmanager_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n acls = [\"XXX.XXX.XXX.X/XX\", \"XX.XXX.XX.X/XX\"]\n}\n```\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "required": [ + "instanceId", + "name", + "projectId" + ], + "inputProperties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SecretsmanagerInstance resources.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object" + } + }, + "stackit:index/secretsmanagerUser:SecretsmanagerUser": { + "description": "Secrets Manager user resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_secretsmanager_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n description = \"Example user\"\n write_enabled = false\n}\n```\n", + "properties": { + "description": { + "type": "string", + "description": "A user chosen description to differentiate between multiple users. Can't be changed after creation.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "password": { + "type": "string", + "description": "An auto-generated password.\n", + "secret": true + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "userId": { + "type": "string", + "description": "The user's ID.\n" + }, + "username": { + "type": "string", + "description": "An auto-generated user name.\n" + }, + "writeEnabled": { + "type": "boolean", + "description": "If true, the user has writeaccess to the secrets engine.\n" + } + }, + "required": [ + "description", + "instanceId", + "password", + "projectId", + "userId", + "username", + "writeEnabled" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "A user chosen description to differentiate between multiple users. Can't be changed after creation.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "writeEnabled": { + "type": "boolean", + "description": "If true, the user has writeaccess to the secrets engine.\n" + } + }, + "requiredInputs": [ + "description", + "instanceId", + "projectId", + "writeEnabled" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SecretsmanagerUser resources.\n", + "properties": { + "description": { + "type": "string", + "description": "A user chosen description to differentiate between multiple users. Can't be changed after creation.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "password": { + "type": "string", + "description": "An auto-generated password.\n", + "secret": true + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "userId": { + "type": "string", + "description": "The user's ID.\n" + }, + "username": { + "type": "string", + "description": "An auto-generated user name.\n" + }, + "writeEnabled": { + "type": "boolean", + "description": "If true, the user has writeaccess to the secrets engine.\n" + } + }, + "type": "object" + } + }, + "stackit:index/securityGroup:SecurityGroup": { + "description": "Security group resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_security_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"my_security_group\"\n labels = {\n \"key\" = \"value\"\n }\n}\n```\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the security group.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the security group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group is associated.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "stateful": { + "type": "boolean", + "description": "Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server.\n" + } + }, + "required": [ + "description", + "name", + "projectId", + "securityGroupId", + "stateful" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "The description of the security group.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the security group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group is associated.\n" + }, + "stateful": { + "type": "boolean", + "description": "Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SecurityGroup resources.\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the security group.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the security group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group is associated.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "stateful": { + "type": "boolean", + "description": "Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server.\n" + } + }, + "type": "object" + } + }, + "stackit:index/securityGroupRule:SecurityGroupRule": { + "description": "Security group rule resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_security_group_rule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n security_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n direction = \"ingress\"\n icmp_parameters = {\n code = 0\n type = 8\n }\n protocol = {\n name = \"icmp\"\n }\n}\n```\n", + "properties": { + "description": { + "type": "string", + "description": "The rule description.\n" + }, + "direction": { + "type": "string", + "description": "The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`.\n" + }, + "etherType": { + "type": "string", + "description": "The ethertype which the rule should match.\n" + }, + "icmpParameters": { + "$ref": "#/types/stackit:index/SecurityGroupRuleIcmpParameters:SecurityGroupRuleIcmpParameters", + "description": "ICMP Parameters. These parameters should only be provided if the protocol is ICMP.\n" + }, + "ipRange": { + "type": "string", + "description": "The remote IP range which the rule should match.\n" + }, + "portRange": { + "$ref": "#/types/stackit:index/SecurityGroupRulePortRange:SecurityGroupRulePortRange", + "description": "The range of ports. This should only be provided if the protocol is not ICMP.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group rule is associated.\n" + }, + "protocol": { + "$ref": "#/types/stackit:index/SecurityGroupRuleProtocol:SecurityGroupRuleProtocol", + "description": "The internet protocol which the rule should match.\n" + }, + "remoteSecurityGroupId": { + "type": "string", + "description": "The remote security group which the rule should match.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "securityGroupRuleId": { + "type": "string", + "description": "The security group rule ID.\n" + } + }, + "required": [ + "direction", + "etherType", + "icmpParameters", + "portRange", + "projectId", + "protocol", + "securityGroupId", + "securityGroupRuleId" + ], + "inputProperties": { + "description": { + "type": "string", + "description": "The rule description.\n" + }, + "direction": { + "type": "string", + "description": "The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`.\n" + }, + "etherType": { + "type": "string", + "description": "The ethertype which the rule should match.\n" + }, + "icmpParameters": { + "$ref": "#/types/stackit:index/SecurityGroupRuleIcmpParameters:SecurityGroupRuleIcmpParameters", + "description": "ICMP Parameters. These parameters should only be provided if the protocol is ICMP.\n" + }, + "ipRange": { + "type": "string", + "description": "The remote IP range which the rule should match.\n" + }, + "portRange": { + "$ref": "#/types/stackit:index/SecurityGroupRulePortRange:SecurityGroupRulePortRange", + "description": "The range of ports. This should only be provided if the protocol is not ICMP.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group rule is associated.\n" + }, + "protocol": { + "$ref": "#/types/stackit:index/SecurityGroupRuleProtocol:SecurityGroupRuleProtocol", + "description": "The internet protocol which the rule should match.\n" + }, + "remoteSecurityGroupId": { + "type": "string", + "description": "The remote security group which the rule should match.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + } + }, + "requiredInputs": [ + "direction", + "projectId", + "securityGroupId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SecurityGroupRule resources.\n", + "properties": { + "description": { + "type": "string", + "description": "The rule description.\n" + }, + "direction": { + "type": "string", + "description": "The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`.\n" + }, + "etherType": { + "type": "string", + "description": "The ethertype which the rule should match.\n" + }, + "icmpParameters": { + "$ref": "#/types/stackit:index/SecurityGroupRuleIcmpParameters:SecurityGroupRuleIcmpParameters", + "description": "ICMP Parameters. These parameters should only be provided if the protocol is ICMP.\n" + }, + "ipRange": { + "type": "string", + "description": "The remote IP range which the rule should match.\n" + }, + "portRange": { + "$ref": "#/types/stackit:index/SecurityGroupRulePortRange:SecurityGroupRulePortRange", + "description": "The range of ports. This should only be provided if the protocol is not ICMP.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group rule is associated.\n" + }, + "protocol": { + "$ref": "#/types/stackit:index/SecurityGroupRuleProtocol:SecurityGroupRuleProtocol", + "description": "The internet protocol which the rule should match.\n" + }, + "remoteSecurityGroupId": { + "type": "string", + "description": "The remote security group which the rule should match.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "securityGroupRuleId": { + "type": "string", + "description": "The security group rule ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/server:Server": { + "description": "Server resource schema. Must have a region specified in the provider configuration.\n\n## Example Usage\n\n### With key pair\n```terraform\nresource \"stackit_key_pair\" \"keypair\" {\n name = \"example-key-pair\"\n public_key = chomp(file(\"path/to/id_rsa.pub\"))\n}\n\nresource \"stackit_server\" \"user-data-from-file\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n name = \"example-server\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n user_data = file(\"${path.module}/cloud-init.yaml\")\n}\n\n```\n\n### Boot from volume\n```terraform\nresource \"stackit_server\" \"boot-from-volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-server\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n availability_zone = \"eu01-1\"\n machine_type = \"g1.1\"\n keypair_name = \"example-keypair\"\n}\n\n```\n\n### Boot from existing volume\n```terraform\nresource \"stackit_volume\" \"example-volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n size = 12\n source = {\n type = \"image\"\n id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n name = \"example-volume\"\n availability_zone = \"eu01-1\"\n}\n\nresource \"stackit_server\" \"boot-from-volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-server\"\n boot_volume = {\n source_type = \"volume\"\n source_id = stackit_volume.example-volume.volume_id\n }\n availability_zone = \"eu01-1\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n}\n\n```\n\n### Network setup\n```terraform\nresource \"stackit_network\" \"network\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-network\"\n nameservers = [\"192.0.2.0\", \"198.51.100.0\", \"203.0.113.0\"]\n ipv4_prefix_length = 24\n}\n\nresource \"stackit_security_group\" \"sec-group\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-security-group\"\n stateful = true\n}\n\nresource \"stackit_security_group_rule\" \"rule\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n security_group_id = stackit_security_group.sec-group.security_group_id\n direction = \"ingress\"\n ether_type = \"IPv4\"\n}\n\nresource \"stackit_network_interface\" \"nic\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_id = stackit_network.network.network_id\n security_group_ids = [stackit_security_group.sec-group.security_group_id]\n}\n\nresource \"stackit_server\" \"server-with-network\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-server\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n network_interfaces = [\n stackit_network_interface.nic.network_interface_id\n ]\t\n}\n\nresource \"stackit_public_ip\" \"public-ip\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_interface_id = stackit_network_interface.nic.network_interface_id\n}\n\n```\n\n### Server with attached volume\n```terraform\nresource \"stackit_volume\" \"example-volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n size = 12\n performance_class = \"storage_premium_perf6\"\n name = \"example-volume\"\n availability_zone = \"eu01-1\"\n}\n\nresource \"stackit_server\" \"server-with-volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-server\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n availability_zone = \"eu01-1\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n}\n\nresource \"stackit_server_volume_attach\" \"attach_volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = stackit_server.server-with-volume.server_id\n volume_id = stackit_volume.example-volume.volume_id\n}\n\n```\n\n### Server with user data (cloud-init)\n```terraform\nresource \"stackit_server\" \"user-data\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n name = \"example-server\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n user_data = \"#!/bin/bash\\n/bin/su\"\n}\n\nresource \"stackit_server\" \"user-data-from-file\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n boot_volume = {\n size = 64\n source_type = \"image\"\n source_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n }\n name = \"example-server\"\n machine_type = \"g1.1\"\n keypair_name = stackit_key_pair.keypair.name\n user_data = file(\"${path.module}/cloud-init.yaml\")\n}\n\n```\n", + "properties": { + "affinityGroup": { + "type": "string", + "description": "The affinity group the server is assigned to.\n" + }, + "availabilityZone": { + "type": "string", + "description": "The availability zone of the server.\n" + }, + "bootVolume": { + "$ref": "#/types/stackit:index/ServerBootVolume:ServerBootVolume", + "description": "The boot volume for the server\n" + }, + "createdAt": { + "type": "string", + "description": "Date-time when the server was created\n" + }, + "desiredStatus": { + "type": "string", + "description": "The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`.\n" + }, + "imageId": { + "type": "string", + "description": "The image ID to be used for an ephemeral disk on the server.\n" + }, + "keypairName": { + "type": "string", + "description": "The name of the keypair used during server creation.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "launchedAt": { + "type": "string", + "description": "Date-time when the server was launched\n" + }, + "machineType": { + "type": "string", + "description": "Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html)\n" + }, + "name": { + "type": "string", + "description": "The name of the server.\n" + }, + "networkInterfaces": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IDs of network interfaces which should be attached to the server. Updating it will recreate the server.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the server is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "updatedAt": { + "type": "string", + "description": "Date-time when the server was updated\n" + }, + "userData": { + "type": "string", + "description": "User data that is passed via cloud-init to the server.\n" + } + }, + "required": [ + "availabilityZone", + "createdAt", + "launchedAt", + "machineType", + "name", + "projectId", + "serverId", + "updatedAt" + ], + "inputProperties": { + "affinityGroup": { + "type": "string", + "description": "The affinity group the server is assigned to.\n" + }, + "availabilityZone": { + "type": "string", + "description": "The availability zone of the server.\n" + }, + "bootVolume": { + "$ref": "#/types/stackit:index/ServerBootVolume:ServerBootVolume", + "description": "The boot volume for the server\n" + }, + "desiredStatus": { + "type": "string", + "description": "The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`.\n" + }, + "imageId": { + "type": "string", + "description": "The image ID to be used for an ephemeral disk on the server.\n" + }, + "keypairName": { + "type": "string", + "description": "The name of the keypair used during server creation.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "machineType": { + "type": "string", + "description": "Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html)\n" + }, + "name": { + "type": "string", + "description": "The name of the server.\n" + }, + "networkInterfaces": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IDs of network interfaces which should be attached to the server. Updating it will recreate the server.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the server is associated.\n" + }, + "userData": { + "type": "string", + "description": "User data that is passed via cloud-init to the server.\n" + } + }, + "requiredInputs": [ + "machineType", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Server resources.\n", + "properties": { + "affinityGroup": { + "type": "string", + "description": "The affinity group the server is assigned to.\n" + }, + "availabilityZone": { + "type": "string", + "description": "The availability zone of the server.\n" + }, + "bootVolume": { + "$ref": "#/types/stackit:index/ServerBootVolume:ServerBootVolume", + "description": "The boot volume for the server\n" + }, + "createdAt": { + "type": "string", + "description": "Date-time when the server was created\n" + }, + "desiredStatus": { + "type": "string", + "description": "The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`.\n" + }, + "imageId": { + "type": "string", + "description": "The image ID to be used for an ephemeral disk on the server.\n" + }, + "keypairName": { + "type": "string", + "description": "The name of the keypair used during server creation.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "launchedAt": { + "type": "string", + "description": "Date-time when the server was launched\n" + }, + "machineType": { + "type": "string", + "description": "Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html)\n" + }, + "name": { + "type": "string", + "description": "The name of the server.\n" + }, + "networkInterfaces": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IDs of network interfaces which should be attached to the server. Updating it will recreate the server.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the server is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "updatedAt": { + "type": "string", + "description": "Date-time when the server was updated\n" + }, + "userData": { + "type": "string", + "description": "User data that is passed via cloud-init to the server.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serverBackupSchedule:ServerBackupSchedule": { + "description": "Server backup schedule resource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\nresource \"stackit_server_backup_schedule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example_backup_schedule_name\"\n rrule = \"DTSTART;TZID=Europe/Sofia:20200803T023000 RRULE:FREQ=DAILY;INTERVAL=1\"\n enabled = true\n backup_properties = {\n name = \"example_backup_name\"\n retention_period = 14\n volume_ids = null\n }\n}\n```\n", + "properties": { + "backupProperties": { + "$ref": "#/types/stackit:index/ServerBackupScheduleBackupProperties:ServerBackupScheduleBackupProperties", + "description": "Backup schedule details for the backups.\n" + }, + "backupScheduleId": { + "type": "integer", + "description": "Backup schedule ID.\n" + }, + "enabled": { + "type": "boolean", + "description": "Is the backup schedule enabled or disabled.\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Backup schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the backup schedule.\n" + } + }, + "required": [ + "backupProperties", + "backupScheduleId", + "enabled", + "name", + "projectId", + "region", + "rrule", + "serverId" + ], + "inputProperties": { + "backupProperties": { + "$ref": "#/types/stackit:index/ServerBackupScheduleBackupProperties:ServerBackupScheduleBackupProperties", + "description": "Backup schedule details for the backups.\n" + }, + "enabled": { + "type": "boolean", + "description": "Is the backup schedule enabled or disabled.\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Backup schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the backup schedule.\n" + } + }, + "requiredInputs": [ + "backupProperties", + "enabled", + "projectId", + "rrule", + "serverId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServerBackupSchedule resources.\n", + "properties": { + "backupProperties": { + "$ref": "#/types/stackit:index/ServerBackupScheduleBackupProperties:ServerBackupScheduleBackupProperties", + "description": "Backup schedule details for the backups.\n" + }, + "backupScheduleId": { + "type": "integer", + "description": "Backup schedule ID.\n" + }, + "enabled": { + "type": "boolean", + "description": "Is the backup schedule enabled or disabled.\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Backup schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the backup schedule.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach": { + "description": "Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot.\n\n## Example Usage\n\n```terraform\nresource \"stackit_server_network_interface_attach\" \"attached_network_interface\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_interface_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network interface attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + } + }, + "required": [ + "networkInterfaceId", + "projectId", + "serverId" + ], + "inputProperties": { + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network interface attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + } + }, + "requiredInputs": [ + "networkInterfaceId", + "projectId", + "serverId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServerNetworkInterfaceAttach resources.\n", + "properties": { + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network interface attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach": { + "description": "Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_server_service_account_attach\" \"attached_service_account\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n service_account_email = \"service-account@stackit.cloud\"\n}\n```\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The service account email.\n" + } + }, + "required": [ + "projectId", + "serverId", + "serviceAccountEmail" + ], + "inputProperties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The service account email.\n" + } + }, + "requiredInputs": [ + "projectId", + "serverId", + "serviceAccountEmail" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServerServiceAccountAttach resources.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The service account email.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serverUpdateSchedule:ServerUpdateSchedule": { + "description": "Server update schedule resource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\nresource \"stackit_server_update_schedule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example_update_schedule_name\"\n rrule = \"DTSTART;TZID=Europe/Sofia:20200803T023000 RRULE:FREQ=DAILY;INTERVAL=1\"\n enabled = true\n maintenance_window = 1\n}\n```\n", + "properties": { + "enabled": { + "type": "boolean", + "description": "Is the update schedule enabled or disabled.\n" + }, + "maintenanceWindow": { + "type": "integer", + "description": "Maintenance window [1..24].\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Update schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the update schedule.\n" + }, + "updateScheduleId": { + "type": "integer", + "description": "Update schedule ID.\n" + } + }, + "required": [ + "enabled", + "maintenanceWindow", + "name", + "projectId", + "region", + "rrule", + "serverId", + "updateScheduleId" + ], + "inputProperties": { + "enabled": { + "type": "boolean", + "description": "Is the update schedule enabled or disabled.\n" + }, + "maintenanceWindow": { + "type": "integer", + "description": "Maintenance window [1..24].\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Update schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the update schedule.\n" + } + }, + "requiredInputs": [ + "enabled", + "maintenanceWindow", + "projectId", + "rrule", + "serverId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServerUpdateSchedule resources.\n", + "properties": { + "enabled": { + "type": "boolean", + "description": "Is the update schedule enabled or disabled.\n" + }, + "maintenanceWindow": { + "type": "integer", + "description": "Maintenance window [1..24].\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Update schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the update schedule.\n" + }, + "updateScheduleId": { + "type": "integer", + "description": "Update schedule ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serverVolumeAttach:ServerVolumeAttach": { + "description": "Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_server_volume_attach\" \"attached_volume\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n volume_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "required": [ + "projectId", + "serverId", + "volumeId" + ], + "inputProperties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "requiredInputs": [ + "projectId", + "serverId", + "volumeId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServerVolumeAttach resources.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume attachment is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serviceAccount:ServiceAccount": { + "description": "Service account resource schema.\n\n## Example Usage\n\n```terraform\nresource \"stackit_service_account\" \"sa\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"sa01\"\n}\n```\n", + "properties": { + "email": { + "type": "string", + "description": "Email of the service account.\n" + }, + "name": { + "type": "string", + "description": "Name of the service account.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account is associated.\n" + } + }, + "required": [ + "email", + "name", + "projectId" + ], + "inputProperties": { + "name": { + "type": "string", + "description": "Name of the service account.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account is associated.\n" + } + }, + "requiredInputs": [ + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServiceAccount resources.\n", + "properties": { + "email": { + "type": "string", + "description": "Email of the service account.\n" + }, + "name": { + "type": "string", + "description": "Name of the service account.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account is associated.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken": { + "description": "Service account access token schema.\n## Example Usage\n\n### Automatically rotate access tokens\n```terraform\nresource \"stackit_service_account\" \"sa\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"sa01\"\n}\n\nresource \"time_rotating\" \"rotate\" {\n rotation_days = 80\n}\n\nresource \"stackit_service_account_access_token\" \"sa_token\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n service_account_email = stackit_service_account.sa.email\n ttl_days = 180\n\n rotate_when_changed = {\n rotation = time_rotating.rotate.id\n }\n}\n\n```\n", + "properties": { + "accessTokenId": { + "type": "string", + "description": "Identifier for the access token linked to the service account.\n" + }, + "active": { + "type": "boolean", + "description": "Indicate whether the token is currently active or inactive\n" + }, + "createdAt": { + "type": "string", + "description": "Timestamp indicating when the access token was created.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the service account token.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Email address linked to the service account.\n" + }, + "token": { + "type": "string", + "description": "JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost.\n", + "secret": true + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the token's validity duration in days. If unspecified, defaults to 90 days.\n" + }, + "validUntil": { + "type": "string", + "description": "Estimated expiration timestamp of the access token. For precise validity, check the JWT details.\n" + } + }, + "required": [ + "accessTokenId", + "active", + "createdAt", + "projectId", + "serviceAccountEmail", + "token", + "ttlDays", + "validUntil" + ], + "inputProperties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the service account token.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Email address linked to the service account.\n" + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the token's validity duration in days. If unspecified, defaults to 90 days.\n" + } + }, + "requiredInputs": [ + "projectId", + "serviceAccountEmail" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServiceAccountAccessToken resources.\n", + "properties": { + "accessTokenId": { + "type": "string", + "description": "Identifier for the access token linked to the service account.\n" + }, + "active": { + "type": "boolean", + "description": "Indicate whether the token is currently active or inactive\n" + }, + "createdAt": { + "type": "string", + "description": "Timestamp indicating when the access token was created.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the service account token.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "Email address linked to the service account.\n" + }, + "token": { + "type": "string", + "description": "JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost.\n", + "secret": true + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the token's validity duration in days. If unspecified, defaults to 90 days.\n" + }, + "validUntil": { + "type": "string", + "description": "Estimated expiration timestamp of the access token. For precise validity, check the JWT details.\n" + } + }, + "type": "object" + } + }, + "stackit:index/serviceAccountKey:ServiceAccountKey": { + "description": "Service account key schema.\n## Example Usage\n\n### Automatically rotate service account keys\n```terraform\nresource \"stackit_service_account\" \"sa\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"sa01\"\n}\n\nresource \"time_rotating\" \"rotate\" {\n rotation_days = 80\n}\n\nresource \"stackit_service_account_key\" \"sa_key\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n service_account_email = stackit_service_account.sa.email\n ttl_days = 90\n\n rotate_when_changed = {\n rotation = time_rotating.rotate.id\n }\t\n}\n\n```\n", + "properties": { + "json": { + "type": "string", + "description": "The raw JSON representation of the service account key json, available for direct use.\n", + "secret": true + }, + "keyId": { + "type": "string", + "description": "The unique identifier for the key associated with the service account.\n" + }, + "projectId": { + "type": "string", + "description": "The STACKIT project ID associated with the service account key.\n" + }, + "publicKey": { + "type": "string", + "description": "Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The email address associated with the service account, used for account identification and communication.\n" + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted\n" + } + }, + "required": [ + "json", + "keyId", + "projectId", + "serviceAccountEmail" + ], + "inputProperties": { + "projectId": { + "type": "string", + "description": "The STACKIT project ID associated with the service account key.\n" + }, + "publicKey": { + "type": "string", + "description": "Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The email address associated with the service account, used for account identification and communication.\n" + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted\n" + } + }, + "requiredInputs": [ + "projectId", + "serviceAccountEmail" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering ServiceAccountKey resources.\n", + "properties": { + "json": { + "type": "string", + "description": "The raw JSON representation of the service account key json, available for direct use.\n", + "secret": true + }, + "keyId": { + "type": "string", + "description": "The unique identifier for the key associated with the service account.\n" + }, + "projectId": { + "type": "string", + "description": "The STACKIT project ID associated with the service account key.\n" + }, + "publicKey": { + "type": "string", + "description": "Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key.\n" + }, + "rotateWhenChanged": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource.\n" + }, + "serviceAccountEmail": { + "type": "string", + "description": "The email address associated with the service account, used for account identification and communication.\n" + }, + "ttlDays": { + "type": "integer", + "description": "Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted\n" + } + }, + "type": "object" + } + }, + "stackit:index/skeCluster:SkeCluster": { + "description": "SKE Cluster Resource schema. Must have a `region` specified in the provider configuration.\n\n\u003e When updating `node_pools` of a `stackit.SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied.\n\n## Example Usage\n\n```terraform\nresource \"stackit_ske_cluster\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example\"\n kubernetes_version = \"x.x\"\n node_pools = [\n {\n name = \"np-example\"\n machine_type = \"x.x\"\n os_version = \"x.x.x\"\n minimum = \"2\"\n maximum = \"3\"\n availability_zones = [\"eu01-3\"]\n }\n ]\n maintenance = {\n enable_kubernetes_version_updates = true\n enable_machine_image_version_updates = true\n start = \"01:00:00Z\"\n end = \"02:00:00Z\"\n }\n}\n```\n", + "properties": { + "allowPrivilegedContainers": { + "type": "boolean", + "description": "Flag to specify if privileged mode for containers is enabled or not.\nThis should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs).\nDeprecated as of Kubernetes 1.25 and later\n" + }, + "egressAddressRanges": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster.\n" + }, + "extensions": { + "$ref": "#/types/stackit:index/SkeClusterExtensions:SkeClusterExtensions", + "description": "A single extensions block as defined below.\n" + }, + "hibernations": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterHibernation:SkeClusterHibernation" + }, + "description": "One or more hibernation block as defined below.\n" + }, + "kubernetesVersion": { + "type": "string", + "description": "Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead`\n", + "deprecationMessage": "Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster." + }, + "kubernetesVersionMin": { + "type": "string", + "description": "The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field.\n" + }, + "kubernetesVersionUsed": { + "type": "string", + "description": "Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "maintenance": { + "$ref": "#/types/stackit:index/SkeClusterMaintenance:SkeClusterMaintenance", + "description": "A single maintenance block as defined below.\n" + }, + "name": { + "type": "string", + "description": "The cluster name.\n" + }, + "network": { + "$ref": "#/types/stackit:index/SkeClusterNetwork:SkeClusterNetwork", + "description": "Network block as defined below.\n" + }, + "nodePools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterNodePool:SkeClusterNodePool" + }, + "description": "One or more `node_pool` block as defined below.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "required": [ + "egressAddressRanges", + "kubernetesVersionUsed", + "maintenance", + "name", + "nodePools", + "projectId", + "region" + ], + "inputProperties": { + "allowPrivilegedContainers": { + "type": "boolean", + "description": "Flag to specify if privileged mode for containers is enabled or not.\nThis should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs).\nDeprecated as of Kubernetes 1.25 and later\n" + }, + "extensions": { + "$ref": "#/types/stackit:index/SkeClusterExtensions:SkeClusterExtensions", + "description": "A single extensions block as defined below.\n" + }, + "hibernations": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterHibernation:SkeClusterHibernation" + }, + "description": "One or more hibernation block as defined below.\n" + }, + "kubernetesVersion": { + "type": "string", + "description": "Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead`\n", + "deprecationMessage": "Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster." + }, + "kubernetesVersionMin": { + "type": "string", + "description": "The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field.\n" + }, + "maintenance": { + "$ref": "#/types/stackit:index/SkeClusterMaintenance:SkeClusterMaintenance", + "description": "A single maintenance block as defined below.\n" + }, + "name": { + "type": "string", + "description": "The cluster name.\n" + }, + "network": { + "$ref": "#/types/stackit:index/SkeClusterNetwork:SkeClusterNetwork", + "description": "Network block as defined below.\n" + }, + "nodePools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterNodePool:SkeClusterNodePool" + }, + "description": "One or more `node_pool` block as defined below.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "requiredInputs": [ + "nodePools", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SkeCluster resources.\n", + "properties": { + "allowPrivilegedContainers": { + "type": "boolean", + "description": "Flag to specify if privileged mode for containers is enabled or not.\nThis should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs).\nDeprecated as of Kubernetes 1.25 and later\n" + }, + "egressAddressRanges": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster.\n" + }, + "extensions": { + "$ref": "#/types/stackit:index/SkeClusterExtensions:SkeClusterExtensions", + "description": "A single extensions block as defined below.\n" + }, + "hibernations": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterHibernation:SkeClusterHibernation" + }, + "description": "One or more hibernation block as defined below.\n" + }, + "kubernetesVersion": { + "type": "string", + "description": "Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead`\n", + "deprecationMessage": "Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster." + }, + "kubernetesVersionMin": { + "type": "string", + "description": "The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field.\n" + }, + "kubernetesVersionUsed": { + "type": "string", + "description": "Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html).\n" + }, + "maintenance": { + "$ref": "#/types/stackit:index/SkeClusterMaintenance:SkeClusterMaintenance", + "description": "A single maintenance block as defined below.\n" + }, + "name": { + "type": "string", + "description": "The cluster name.\n" + }, + "network": { + "$ref": "#/types/stackit:index/SkeClusterNetwork:SkeClusterNetwork", + "description": "Network block as defined below.\n" + }, + "nodePools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/SkeClusterNodePool:SkeClusterNodePool" + }, + "description": "One or more `node_pool` block as defined below.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object" + } + }, + "stackit:index/skeKubeconfig:SkeKubeconfig": { + "description": "SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_ske_kubeconfig\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n cluster_name = \"example-cluster\"\n refresh = true\n}\n```\n", + "properties": { + "clusterName": { + "type": "string", + "description": "Name of the SKE cluster.\n" + }, + "creationTime": { + "type": "string", + "description": "Date-time when the kubeconfig was created\n" + }, + "expiration": { + "type": "integer", + "description": "Expiration time of the kubeconfig, in seconds. Defaults to `3600`\n" + }, + "expiresAt": { + "type": "string", + "description": "Timestamp when the kubeconfig expires\n" + }, + "kubeConfig": { + "type": "string", + "description": "Raw short-lived admin kubeconfig.\n", + "secret": true + }, + "kubeConfigId": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "refresh": { + "type": "boolean", + "description": "If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place\n" + } + }, + "required": [ + "clusterName", + "creationTime", + "expiration", + "expiresAt", + "kubeConfig", + "kubeConfigId", + "projectId" + ], + "inputProperties": { + "clusterName": { + "type": "string", + "description": "Name of the SKE cluster.\n" + }, + "expiration": { + "type": "integer", + "description": "Expiration time of the kubeconfig, in seconds. Defaults to `3600`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "refresh": { + "type": "boolean", + "description": "If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place\n" + } + }, + "requiredInputs": [ + "clusterName", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SkeKubeconfig resources.\n", + "properties": { + "clusterName": { + "type": "string", + "description": "Name of the SKE cluster.\n" + }, + "creationTime": { + "type": "string", + "description": "Date-time when the kubeconfig was created\n" + }, + "expiration": { + "type": "integer", + "description": "Expiration time of the kubeconfig, in seconds. Defaults to `3600`\n" + }, + "expiresAt": { + "type": "string", + "description": "Timestamp when the kubeconfig expires\n" + }, + "kubeConfig": { + "type": "string", + "description": "Raw short-lived admin kubeconfig.\n", + "secret": true + }, + "kubeConfigId": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "refresh": { + "type": "boolean", + "description": "If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place\n" + } + }, + "type": "object" + } + }, + "stackit:index/sqlserverflexInstance:SqlserverflexInstance": { + "description": "SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_sqlserverflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-instance\"\n acl = [\"XXX.XXX.XXX.X/XX\", \"XX.XXX.XX.X/XX\"]\n backup_schedule = \"00 00 * * *\"\n flavor = {\n cpu = 4\n ram = 16\n }\n storage = {\n class = \"class\"\n size = 5\n }\n version = 2022\n}\n```\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the SQLServer Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\")\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceFlavor:SqlserverflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceOptions:SqlserverflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceStorage:SqlserverflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "required": [ + "acls", + "backupSchedule", + "flavor", + "instanceId", + "name", + "options", + "projectId", + "region", + "replicas", + "storage", + "version" + ], + "inputProperties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the SQLServer Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\")\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceFlavor:SqlserverflexInstanceFlavor" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceOptions:SqlserverflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "storage": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceStorage:SqlserverflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "requiredInputs": [ + "flavor", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SqlserverflexInstance resources.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the SQLServer Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\")\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceFlavor:SqlserverflexInstanceFlavor" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceOptions:SqlserverflexInstanceOptions" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/SqlserverflexInstanceStorage:SqlserverflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object" + } + }, + "stackit:index/sqlserverflexUser:SqlserverflexUser": { + "description": "SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_sqlserverflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n username = \"username\"\n roles = [\"role\"]\n}\n```\n", + "properties": { + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "password": { + "type": "string", + "description": "Password of the user account.\n", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##`\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string", + "description": "Username of the SQLServer Flex instance.\n" + } + }, + "required": [ + "host", + "instanceId", + "password", + "port", + "projectId", + "region", + "userId", + "username" + ], + "inputProperties": { + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##`\n" + }, + "username": { + "type": "string", + "description": "Username of the SQLServer Flex instance.\n" + } + }, + "requiredInputs": [ + "instanceId", + "projectId", + "username" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering SqlserverflexUser resources.\n", + "properties": { + "host": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "password": { + "type": "string", + "description": "Password of the user account.\n", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##`\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string", + "description": "Username of the SQLServer Flex instance.\n" + } + }, + "type": "object" + } + }, + "stackit:index/volume:Volume": { + "description": "Volume resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\nresource \"stackit_volume\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"my_volume\"\n availability_zone = \"eu01-1\"\n size = 64\n labels = {\n \"key\" = \"value\"\n }\n}\n```\n", + "properties": { + "availabilityZone": { + "type": "string", + "description": "The availability zone of the volume.\n" + }, + "description": { + "type": "string", + "description": "The description of the volume.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the volume.\n" + }, + "performanceClass": { + "type": "string", + "description": "The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29)\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID of the server to which the volume is attached to.\n" + }, + "size": { + "type": "integer", + "description": "The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided\n" + }, + "source": { + "$ref": "#/types/stackit:index/VolumeSource:VolumeSource", + "description": "The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "required": [ + "availabilityZone", + "description", + "name", + "performanceClass", + "projectId", + "serverId", + "size", + "volumeId" + ], + "inputProperties": { + "availabilityZone": { + "type": "string", + "description": "The availability zone of the volume.\n" + }, + "description": { + "type": "string", + "description": "The description of the volume.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the volume.\n" + }, + "performanceClass": { + "type": "string", + "description": "The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29)\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume is associated.\n" + }, + "size": { + "type": "integer", + "description": "The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided\n" + }, + "source": { + "$ref": "#/types/stackit:index/VolumeSource:VolumeSource", + "description": "The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided\n" + } + }, + "requiredInputs": [ + "availabilityZone", + "projectId" + ], + "stateInputs": { + "description": "Input properties used for looking up and filtering Volume resources.\n", + "properties": { + "availabilityZone": { + "type": "string", + "description": "The availability zone of the volume.\n" + }, + "description": { + "type": "string", + "description": "The description of the volume.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the volume.\n" + }, + "performanceClass": { + "type": "string", + "description": "The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29)\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID of the server to which the volume is attached to.\n" + }, + "size": { + "type": "integer", + "description": "The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided\n" + }, + "source": { + "$ref": "#/types/stackit:index/VolumeSource:VolumeSource", + "description": "The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "type": "object" + } + } + }, + "functions": { + "pulumi:providers:stackit/terraformConfig": { + "description": "This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider.", + "inputs": { + "properties": { + "__self__": { + "type": "ref", + "$ref": "#/resources/pulumi:providers:stackit" + } + }, + "type": "pulumi:providers:stackit/terraformConfig", + "required": [ + "__self__" + ] + }, + "outputs": { + "properties": { + "result": { + "additionalProperties": { + "$ref": "pulumi.json#/Any" + }, + "type": "object" + } + }, + "required": [ + "result" + ], + "type": "object" + } + }, + "stackit:index/getAffinityGroup:getAffinityGroup": { + "description": "Affinity Group schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_affinity_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n affinity_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getAffinityGroup.\n", + "properties": { + "affinityGroupId": { + "type": "string", + "description": "The affinity group ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the affinity group is associated.\n" + } + }, + "type": "object", + "required": [ + "affinityGroupId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getAffinityGroup.\n", + "properties": { + "affinityGroupId": { + "type": "string", + "description": "The affinity group ID.\n" + }, + "id": { + "type": "string" + }, + "members": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Affinity Group schema. Must have a `region` specified in the provider configuration.\n" + }, + "name": { + "type": "string", + "description": "The name of the affinity group.\n" + }, + "policy": { + "type": "string", + "description": "The policy of the affinity group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the affinity group is associated.\n" + } + }, + "type": "object", + "required": [ + "affinityGroupId", + "id", + "members", + "name", + "policy", + "projectId" + ] + } + }, + "stackit:index/getCdnCustomDomain:getCdnCustomDomain": { + "description": "CDN distribution data source schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_cdn_custom_domain\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n distribution_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"https://xxx.xxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getCdnCustomDomain.\n", + "properties": { + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + } + }, + "type": "object", + "required": [ + "distributionId", + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getCdnCustomDomain.\n", + "properties": { + "distributionId": { + "type": "string", + "description": "CDN distribution ID\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + } + }, + "type": "object", + "required": [ + "distributionId", + "errors", + "id", + "name", + "projectId", + "status" + ] + } + }, + "stackit:index/getCdnDistribution:getCdnDistribution": { + "description": "CDN distribution data source schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_cdn_distribution\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n distribution_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getCdnDistribution.\n", + "properties": { + "distributionId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + } + }, + "type": "object", + "required": [ + "distributionId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getCdnDistribution.\n", + "properties": { + "config": { + "$ref": "#/types/stackit:index/getCdnDistributionConfig:getCdnDistributionConfig", + "description": "The distribution configuration\n" + }, + "createdAt": { + "type": "string", + "description": "Time when the distribution was created\n" + }, + "distributionId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "domains": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getCdnDistributionDomain:getCdnDistributionDomain" + }, + "description": "List of configured domains for the distribution\n" + }, + "errors": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of distribution errors\n" + }, + "id": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID associated with the distribution\n" + }, + "status": { + "type": "string", + "description": "Status of the distribution\n" + }, + "updatedAt": { + "type": "string", + "description": "Time when the distribution was last updated\n" + } + }, + "type": "object", + "required": [ + "config", + "createdAt", + "distributionId", + "domains", + "errors", + "id", + "projectId", + "status", + "updatedAt" + ] + } + }, + "stackit:index/getDnsRecordSet:getDnsRecordSet": { + "description": "DNS Record Set Resource schema.\n\n## Example Usage\n\n```terraform\ndata \"stackit_dns_record_set\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n zone_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n record_set_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getDnsRecordSet.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns record set is associated.\n" + }, + "recordSetId": { + "type": "string", + "description": "The rr set id.\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID to which is dns record set is associated.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "recordSetId", + "zoneId" + ] + }, + "outputs": { + "description": "A collection of values returned by getDnsRecordSet.\n", + "properties": { + "active": { + "type": "boolean", + "description": "Specifies if the record set is active or not.\n" + }, + "comment": { + "type": "string", + "description": "Comment.\n" + }, + "error": { + "type": "string", + "description": "Error shows error in case create/update/delete failed.\n" + }, + "fqdn": { + "type": "string", + "description": "Fully qualified domain name (FQDN) of the record set.\n" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string", + "description": "Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns record set is associated.\n" + }, + "recordSetId": { + "type": "string", + "description": "The rr set id.\n" + }, + "records": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Records.\n" + }, + "state": { + "type": "string", + "description": "Record set state.\n" + }, + "ttl": { + "type": "integer", + "description": "Time to live. E.g. 3600\n" + }, + "type": { + "type": "string", + "description": "The record set type. E.g. `A` or `CNAME`\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID to which is dns record set is associated.\n" + } + }, + "type": "object", + "required": [ + "active", + "comment", + "error", + "fqdn", + "id", + "name", + "projectId", + "recordSetId", + "records", + "state", + "ttl", + "type", + "zoneId" + ] + } + }, + "stackit:index/getDnsZone:getDnsZone": { + "description": "DNS Zone resource schema.\n\n## Example Usage\n\n```terraform\ndata \"stackit_dns_zone\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n zone_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getDnsZone.\n", + "properties": { + "dnsName": { + "type": "string", + "description": "The zone name. E.g. `example.com`\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns zone is associated.\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID.\n" + } + }, + "type": "object", + "required": [ + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getDnsZone.\n", + "properties": { + "acl": { + "type": "string", + "description": "The access control list.\n" + }, + "active": { + "type": "boolean" + }, + "contactEmail": { + "type": "string", + "description": "A contact e-mail for the zone.\n" + }, + "defaultTtl": { + "type": "integer", + "description": "Default time to live.\n" + }, + "description": { + "type": "string", + "description": "Description of the zone.\n" + }, + "dnsName": { + "type": "string", + "description": "The zone name. E.g. `example.com`\n" + }, + "expireTime": { + "type": "integer", + "description": "Expire time.\n" + }, + "id": { + "type": "string" + }, + "isReverseZone": { + "type": "boolean", + "description": "Specifies, if the zone is a reverse zone or not.\n" + }, + "name": { + "type": "string", + "description": "The user given name of the zone.\n" + }, + "negativeCache": { + "type": "integer", + "description": "Negative caching.\n" + }, + "primaries": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Primary name server for secondary zone.\n" + }, + "primaryNameServer": { + "type": "string", + "description": "Primary name server. FQDN.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the dns zone is associated.\n" + }, + "recordCount": { + "type": "integer", + "description": "Record count how many records are in the zone.\n" + }, + "refreshTime": { + "type": "integer", + "description": "Refresh time.\n" + }, + "retryTime": { + "type": "integer", + "description": "Retry time.\n" + }, + "serialNumber": { + "type": "integer", + "description": "Serial number.\n" + }, + "state": { + "type": "string", + "description": "Zone state.\n" + }, + "type": { + "type": "string", + "description": "Zone type.\n" + }, + "visibility": { + "type": "string", + "description": "Visibility of the zone.\n" + }, + "zoneId": { + "type": "string", + "description": "The zone ID.\n" + } + }, + "type": "object", + "required": [ + "acl", + "active", + "contactEmail", + "defaultTtl", + "description", + "expireTime", + "id", + "isReverseZone", + "name", + "negativeCache", + "primaries", + "primaryNameServer", + "projectId", + "recordCount", + "refreshTime", + "retryTime", + "serialNumber", + "state", + "type", + "visibility" + ] + } + }, + "stackit:index/getGit:getGit": { + "description": "Git Instance datasource schema.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_git\" \"git\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getGit.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID linked to the git instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the git instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getGit.\n", + "properties": { + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID linked to the git instance.\n" + }, + "name": { + "type": "string", + "description": "Unique name linked to the git instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the git instance is associated.\n" + }, + "url": { + "type": "string", + "description": "Url linked to the git instance.\n" + }, + "version": { + "type": "string", + "description": "Version linked to the git instance.\n" + } + }, + "type": "object", + "required": [ + "id", + "instanceId", + "name", + "projectId", + "url", + "version" + ] + } + }, + "stackit:index/getImage:getImage": { + "description": "Image datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_image\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n image_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getImage.\n", + "properties": { + "imageId": { + "type": "string", + "description": "The image ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the image is associated.\n" + } + }, + "type": "object", + "required": [ + "imageId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getImage.\n", + "properties": { + "checksum": { + "$ref": "#/types/stackit:index/getImageChecksum:getImageChecksum", + "description": "Representation of an image checksum.\n" + }, + "config": { + "$ref": "#/types/stackit:index/getImageConfig:getImageConfig", + "description": "Properties to set hardware and scheduling settings for an image.\n" + }, + "diskFormat": { + "type": "string", + "description": "The disk format of the image.\n" + }, + "id": { + "type": "string" + }, + "imageId": { + "type": "string", + "description": "The image ID.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "minDiskSize": { + "type": "integer", + "description": "The minimum disk size of the image in GB.\n" + }, + "minRam": { + "type": "integer", + "description": "The minimum RAM of the image in MB.\n" + }, + "name": { + "type": "string", + "description": "The name of the image.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the image is associated.\n" + }, + "protected": { + "type": "boolean", + "description": "Whether the image is protected.\n" + }, + "scope": { + "type": "string", + "description": "The scope of the image.\n" + } + }, + "type": "object", + "required": [ + "checksum", + "config", + "diskFormat", + "id", + "imageId", + "labels", + "minDiskSize", + "minRam", + "name", + "projectId", + "protected", + "scope" + ] + } + }, + "stackit:index/getKeyPair:getKeyPair": { + "description": "Key pair resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_key_pair\" \"example\" {\n name = \"example-key-pair-name\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getKeyPair.\n", + "properties": { + "name": { + "type": "string", + "description": "The name of the SSH key pair.\n" + } + }, + "type": "object", + "required": [ + "name" + ] + }, + "outputs": { + "description": "A collection of values returned by getKeyPair.\n", + "properties": { + "fingerprint": { + "type": "string", + "description": "The fingerprint of the public SSH key.\n" + }, + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container.\n" + }, + "name": { + "type": "string", + "description": "The name of the SSH key pair.\n" + }, + "publicKey": { + "type": "string", + "description": "A string representation of the public SSH key. E.g., `ssh-rsa \u003ckey_data\u003e` or `ssh-ed25519 \u003ckey-data\u003e`.\n" + } + }, + "type": "object", + "required": [ + "fingerprint", + "id", + "labels", + "name", + "publicKey" + ] + } + }, + "stackit:index/getLoadbalancer:getLoadbalancer": { + "description": "Load Balancer data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_loadbalancer\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-load-balancer\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getLoadbalancer.\n", + "properties": { + "name": { + "type": "string", + "description": "Load balancer name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the Load Balancer is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getLoadbalancer.\n", + "properties": { + "externalAddress": { + "type": "string", + "description": "External Load Balancer IP address where this Load Balancer is exposed.\n" + }, + "id": { + "type": "string" + }, + "listeners": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getLoadbalancerListener:getLoadbalancerListener" + }, + "description": "List of all listeners which will accept traffic. Limited to 20.\n" + }, + "name": { + "type": "string", + "description": "Load balancer name.\n" + }, + "networks": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getLoadbalancerNetwork:getLoadbalancerNetwork" + }, + "description": "List of networks that listeners and targets reside in.\n" + }, + "options": { + "$ref": "#/types/stackit:index/getLoadbalancerOptions:getLoadbalancerOptions", + "description": "Defines any optional functionality you want to have enabled on your load balancer.\n" + }, + "privateAddress": { + "type": "string", + "description": "Transient private Load Balancer IP address. It can change any time.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the Load Balancer is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "targetPools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getLoadbalancerTargetPool:getLoadbalancerTargetPool" + }, + "description": "List of all target pools which will be used in the Load Balancer. Limited to 20.\n" + } + }, + "type": "object", + "required": [ + "externalAddress", + "id", + "listeners", + "name", + "networks", + "options", + "privateAddress", + "projectId", + "targetPools" + ] + } + }, + "stackit:index/getLogmeCredential:getLogmeCredential": { + "description": "LogMe credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_logme_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getLogmeCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getLogmeCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "credentialId", + "host", + "id", + "instanceId", + "password", + "port", + "projectId", + "uri", + "username" + ] + } + }, + "stackit:index/getLogmeInstance:getLogmeInstance": { + "description": "LogMe instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_logme_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getLogmeInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getLogmeInstance.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "id": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the LogMe instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/getLogmeInstanceParameters:getLogmeInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object", + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "id", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ] + } + }, + "stackit:index/getMariadbCredential:getMariadbCredential": { + "description": "MariaDB credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_mariadb_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getMariadbCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getMariadbCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "credentialId", + "host", + "hosts", + "id", + "instanceId", + "name", + "password", + "port", + "projectId", + "uri", + "username" + ] + } + }, + "stackit:index/getMariadbInstance:getMariadbInstance": { + "description": "MariaDB instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_mariadb_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getMariadbInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getMariadbInstance.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "id": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MariaDB instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/getMariadbInstanceParameters:getMariadbInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object", + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "id", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ] + } + }, + "stackit:index/getMongodbflexInstance:getMongodbflexInstance": { + "description": "MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_mongodbflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getMongodbflexInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getMongodbflexInstance.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the MongoDB Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\").\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/getMongodbflexInstanceFlavor:getMongodbflexInstanceFlavor" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/getMongodbflexInstanceOptions:getMongodbflexInstanceOptions", + "description": "Custom parameters for the MongoDB Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/getMongodbflexInstanceStorage:getMongodbflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object", + "required": [ + "acls", + "backupSchedule", + "flavor", + "id", + "instanceId", + "name", + "options", + "projectId", + "replicas", + "storage", + "version" + ] + } + }, + "stackit:index/getMongodbflexUser:getMongodbflexUser": { + "description": "MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_mongodbflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n user_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getMongodbflexUser.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId", + "userId" + ] + }, + "outputs": { + "description": "A collection of values returned by getMongodbflexUser.\n", + "properties": { + "database": { + "type": "string" + }, + "host": { + "type": "string" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the MongoDB Flex instance.\n" + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "database", + "host", + "id", + "instanceId", + "port", + "projectId", + "roles", + "userId", + "username" + ] + } + }, + "stackit:index/getNetwork:getNetwork": { + "description": "Network resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_network\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getNetwork.\n", + "properties": { + "networkId": { + "type": "string", + "description": "The network ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + } + }, + "type": "object", + "required": [ + "networkId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getNetwork.\n", + "properties": { + "id": { + "type": "string" + }, + "ipv4Gateway": { + "type": "string", + "description": "The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv4Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 nameservers of the network.\n" + }, + "ipv4Prefix": { + "type": "string", + "description": "The IPv4 prefix of the network (CIDR).\n", + "deprecationMessage": "The API supports reading multiple prefixes. So using the attribute 'ipv4_prefixes` should be preferred. This attribute will be populated with the first element from the list" + }, + "ipv4PrefixLength": { + "type": "integer", + "description": "The IPv4 prefix length of the network.\n" + }, + "ipv4Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv4 prefixes of the network.\n" + }, + "ipv6Gateway": { + "type": "string", + "description": "The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway.\n" + }, + "ipv6Nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 nameservers of the network.\n" + }, + "ipv6Prefix": { + "type": "string", + "description": "The IPv6 prefix of the network (CIDR).\n", + "deprecationMessage": "The API supports reading multiple prefixes. So using the attribute 'ipv6_prefixes` should be preferred. This attribute will be populated with the first element from the list" + }, + "ipv6PrefixLength": { + "type": "integer", + "description": "The IPv6 prefix length of the network.\n" + }, + "ipv6Prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IPv6 prefixes of the network.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the network.\n" + }, + "nameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4.\n", + "deprecationMessage": "Use `ipv4_nameservers` to configure the nameservers for IPv4." + }, + "networkId": { + "type": "string", + "description": "The network ID.\n" + }, + "prefixes": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks.\n", + "deprecationMessage": "Use `ipv4_prefixes` to read the prefixes of the IPv4 networks." + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network is associated.\n" + }, + "publicIp": { + "type": "string", + "description": "The public IP of the network.\n" + }, + "routed": { + "type": "boolean", + "description": "Shows if the network is routed and therefore accessible from other networks.\n" + } + }, + "type": "object", + "required": [ + "id", + "ipv4Gateway", + "ipv4Nameservers", + "ipv4Prefix", + "ipv4PrefixLength", + "ipv4Prefixes", + "ipv6Gateway", + "ipv6Nameservers", + "ipv6Prefix", + "ipv6PrefixLength", + "ipv6Prefixes", + "labels", + "name", + "nameservers", + "networkId", + "prefixes", + "projectId", + "publicIp", + "routed" + ] + } + }, + "stackit:index/getNetworkArea:getNetworkArea": { + "description": "Network area datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_network_area\" \"example\" {\n organization_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_area_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getNetworkArea.\n", + "properties": { + "networkAreaId": { + "type": "string", + "description": "The network area ID.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + } + }, + "type": "object", + "required": [ + "networkAreaId", + "organizationId" + ] + }, + "outputs": { + "description": "A collection of values returned by getNetworkArea.\n", + "properties": { + "defaultNameservers": { + "type": "array", + "items": { + "type": "string" + }, + "description": "List of DNS Servers/Nameservers.\n" + }, + "defaultPrefixLength": { + "type": "integer", + "description": "The default prefix length for networks in the network area.\n" + }, + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "maxPrefixLength": { + "type": "integer", + "description": "The maximal prefix length for networks in the network area.\n" + }, + "minPrefixLength": { + "type": "integer", + "description": "The minimal prefix length for networks in the network area.\n" + }, + "name": { + "type": "string", + "description": "The name of the network area.\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID.\n" + }, + "networkRanges": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getNetworkAreaNetworkRange:getNetworkAreaNetworkRange" + }, + "description": "List of Network ranges.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "projectCount": { + "type": "integer", + "description": "The amount of projects currently referencing this area.\n" + }, + "transferNetwork": { + "type": "string", + "description": "Classless Inter-Domain Routing (CIDR).\n" + } + }, + "type": "object", + "required": [ + "defaultNameservers", + "defaultPrefixLength", + "id", + "labels", + "maxPrefixLength", + "minPrefixLength", + "name", + "networkAreaId", + "networkRanges", + "organizationId", + "projectCount", + "transferNetwork" + ] + } + }, + "stackit:index/getNetworkAreaRoute:getNetworkAreaRoute": { + "description": "Network area route data resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_network_area_route\" \"example\" {\n organization_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_area_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_area_route_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getNetworkAreaRoute.\n", + "properties": { + "networkAreaId": { + "type": "string", + "description": "The network area ID to which the network area route is associated.\n" + }, + "networkAreaRouteId": { + "type": "string", + "description": "The network area route ID.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + } + }, + "type": "object", + "required": [ + "networkAreaId", + "networkAreaRouteId", + "organizationId" + ] + }, + "outputs": { + "description": "A collection of values returned by getNetworkAreaRoute.\n", + "properties": { + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkAreaId": { + "type": "string", + "description": "The network area ID to which the network area route is associated.\n" + }, + "networkAreaRouteId": { + "type": "string", + "description": "The network area route ID.\n" + }, + "nextHop": { + "type": "string", + "description": "The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address.\n" + }, + "organizationId": { + "type": "string", + "description": "STACKIT organization ID to which the network area is associated.\n" + }, + "prefix": { + "type": "string", + "description": "The network, that is reachable though the Next Hop. Should use CIDR notation.\n" + } + }, + "type": "object", + "required": [ + "id", + "labels", + "networkAreaId", + "networkAreaRouteId", + "nextHop", + "organizationId", + "prefix" + ] + } + }, + "stackit:index/getNetworkInterface:getNetworkInterface": { + "description": "Network interface datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_network_interface\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n network_interface_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getNetworkInterface.\n", + "properties": { + "networkId": { + "type": "string", + "description": "The network ID to which the network interface is associated.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network interface is associated.\n" + } + }, + "type": "object", + "required": [ + "networkId", + "networkInterfaceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getNetworkInterface.\n", + "properties": { + "allowedAddresses": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of CIDR (Classless Inter-Domain Routing) notations.\n" + }, + "device": { + "type": "string", + "description": "The device UUID of the network interface.\n" + }, + "id": { + "type": "string" + }, + "ipv4": { + "type": "string", + "description": "The IPv4 address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a network interface.\n" + }, + "mac": { + "type": "string", + "description": "The MAC address of network interface.\n" + }, + "name": { + "type": "string", + "description": "The name of the network interface.\n" + }, + "networkId": { + "type": "string", + "description": "The network ID to which the network interface is associated.\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "The network interface ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the network interface is associated.\n" + }, + "security": { + "type": "boolean", + "description": "The Network Interface Security. If set to false, then no security groups will apply to this network interface.\n" + }, + "securityGroupIds": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The list of security group UUIDs. If security is set to false, setting this field will lead to an error.\n" + }, + "type": { + "type": "string", + "description": "Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`.\n" + } + }, + "type": "object", + "required": [ + "allowedAddresses", + "device", + "id", + "ipv4", + "labels", + "mac", + "name", + "networkId", + "networkInterfaceId", + "projectId", + "security", + "securityGroupIds", + "type" + ] + } + }, + "stackit:index/getObjectstorageBucket:getObjectstorageBucket": { + "description": "ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_objectstorage_bucket\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-name\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObjectstorageBucket.\n", + "properties": { + "name": { + "type": "string", + "description": "The bucket name. It must be DNS conform.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the bucket is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObjectstorageBucket.\n", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string", + "description": "The bucket name. It must be DNS conform.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the bucket is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urlPathStyle": { + "type": "string" + }, + "urlVirtualHostedStyle": { + "type": "string" + } + }, + "type": "object", + "required": [ + "id", + "name", + "projectId", + "urlPathStyle", + "urlVirtualHostedStyle" + ] + } + }, + "stackit:index/getObjectstorageCredential:getObjectstorageCredential": { + "description": "ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_objectstorage_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credentials_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObjectstorageCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential ID.\n" + }, + "credentialsGroupId": { + "type": "string", + "description": "The credential group ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the credential group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "credentialsGroupId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObjectstorageCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential ID.\n" + }, + "credentialsGroupId": { + "type": "string", + "description": "The credential group ID.\n" + }, + "expirationTimestamp": { + "type": "string" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the credential group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "credentialsGroupId", + "expirationTimestamp", + "id", + "name", + "projectId" + ] + } + }, + "stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup": { + "description": "ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_objectstorage_credentials_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credentials_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObjectstorageCredentialsGroup.\n", + "properties": { + "credentialsGroupId": { + "type": "string", + "description": "The credentials group ID.\n" + }, + "projectId": { + "type": "string", + "description": "Object Storage Project ID to which the credentials group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "credentialsGroupId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObjectstorageCredentialsGroup.\n", + "properties": { + "credentialsGroupId": { + "type": "string", + "description": "The credentials group ID.\n" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string", + "description": "The credentials group's display name.\n" + }, + "projectId": { + "type": "string", + "description": "Object Storage Project ID to which the credentials group is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "urn": { + "type": "string", + "description": "Credentials group uniform resource name (URN)\n" + } + }, + "type": "object", + "required": [ + "credentialsGroupId", + "id", + "name", + "projectId", + "urn" + ] + } + }, + "stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup": { + "description": "Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_observability_alertgroup\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-alert-group\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObservabilityAlertgroup.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the alert group is associated.\n" + }, + "name": { + "type": "string", + "description": "The name of the alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the alert group is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObservabilityAlertgroup.\n", + "properties": { + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityAlertgroupRule:getObservabilityAlertgroupRule" + } + } + }, + "type": "object", + "required": [ + "id", + "instanceId", + "interval", + "name", + "projectId", + "rules" + ] + } + }, + "stackit:index/getObservabilityInstance:getObservabilityInstance": { + "description": "Observability instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_observability_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObservabilityInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "The Observability instance ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObservabilityInstance.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation.\n" + }, + "alertConfig": { + "$ref": "#/types/stackit:index/getObservabilityInstanceAlertConfig:getObservabilityInstanceAlertConfig", + "description": "Alert configuration for the instance.\n" + }, + "alertingUrl": { + "type": "string", + "description": "Specifies Alerting URL.\n" + }, + "dashboardUrl": { + "type": "string", + "description": "Specifies Observability instance dashboard URL.\n" + }, + "grafanaInitialAdminPassword": { + "type": "string", + "description": "Specifies an initial Grafana admin password.\n", + "secret": true + }, + "grafanaInitialAdminUser": { + "type": "string", + "description": "Specifies an initial Grafana admin username.\n" + }, + "grafanaPublicReadAccess": { + "type": "boolean", + "description": "If true, anyone can access Grafana dashboards without logging in.\n" + }, + "grafanaUrl": { + "type": "string", + "description": "Specifies Grafana URL.\n" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "The Observability instance ID.\n" + }, + "isUpdatable": { + "type": "boolean", + "description": "Specifies if the instance can be updated.\n" + }, + "jaegerTracesUrl": { + "type": "string" + }, + "jaegerUiUrl": { + "type": "string" + }, + "logsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing logs.\n" + }, + "logsUrl": { + "type": "string", + "description": "Specifies Logs URL.\n" + }, + "metricsPushUrl": { + "type": "string", + "description": "Specifies URL for pushing metrics.\n" + }, + "metricsRetentionDays": { + "type": "integer", + "description": "Specifies for how many days the raw metrics are kept.\n" + }, + "metricsRetentionDays1hDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled).\n" + }, + "metricsRetentionDays5mDownsampling": { + "type": "integer", + "description": "Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled).\n" + }, + "metricsUrl": { + "type": "string", + "description": "Specifies metrics URL.\n" + }, + "name": { + "type": "string", + "description": "The name of the Observability instance.\n" + }, + "otlpTracesUrl": { + "type": "string" + }, + "parameters": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Additional parameters.\n" + }, + "planId": { + "type": "string", + "description": "The Observability plan ID.\n" + }, + "planName": { + "type": "string", + "description": "Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "targetsUrl": { + "type": "string", + "description": "Specifies Targets URL.\n" + }, + "zipkinSpansUrl": { + "type": "string" + } + }, + "type": "object", + "required": [ + "acls", + "alertConfig", + "alertingUrl", + "dashboardUrl", + "grafanaInitialAdminPassword", + "grafanaInitialAdminUser", + "grafanaPublicReadAccess", + "grafanaUrl", + "id", + "instanceId", + "isUpdatable", + "jaegerTracesUrl", + "jaegerUiUrl", + "logsPushUrl", + "logsUrl", + "metricsPushUrl", + "metricsRetentionDays", + "metricsRetentionDays1hDownsampling", + "metricsRetentionDays5mDownsampling", + "metricsUrl", + "name", + "otlpTracesUrl", + "parameters", + "planId", + "planName", + "projectId", + "targetsUrl", + "zipkinSpansUrl" + ] + } + }, + "stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup": { + "description": "Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_observability_logalertgroup\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-log-alert-group\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObservabilityLogalertgroup.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the log alert group is associated.\n" + }, + "name": { + "type": "string", + "description": "The name of the log alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the log alert group is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObservabilityLogalertgroup.\n", + "properties": { + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the log alert group is associated.\n" + }, + "interval": { + "type": "string", + "description": "Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'.\n" + }, + "name": { + "type": "string", + "description": "The name of the log alert group. Is the identifier and must be unique in the group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the log alert group is associated.\n" + }, + "rules": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityLogalertgroupRule:getObservabilityLogalertgroupRule" + } + } + }, + "type": "object", + "required": [ + "id", + "instanceId", + "interval", + "name", + "projectId", + "rules" + ] + } + }, + "stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig": { + "description": "Observability scrape config data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_observability_scrapeconfig\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getObservabilityScrapeconfig.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the scraping job is associated.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the scraping job\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the scraping job is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getObservabilityScrapeconfig.\n", + "properties": { + "basicAuth": { + "$ref": "#/types/stackit:index/getObservabilityScrapeconfigBasicAuth:getObservabilityScrapeconfigBasicAuth", + "description": "A basic authentication block.\n" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "Observability instance ID to which the scraping job is associated.\n" + }, + "metricsPath": { + "type": "string", + "description": "Specifies the job scraping url path.\n" + }, + "name": { + "type": "string", + "description": "Specifies the name of the scraping job\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the scraping job is associated.\n" + }, + "saml2": { + "$ref": "#/types/stackit:index/getObservabilityScrapeconfigSaml2:getObservabilityScrapeconfigSaml2", + "description": "A SAML2 configuration block.\n" + }, + "sampleLimit": { + "type": "integer", + "description": "Specifies the scrape sample limit.\n" + }, + "scheme": { + "type": "string", + "description": "Specifies the http scheme.\n" + }, + "scrapeInterval": { + "type": "string", + "description": "Specifies the scrape interval as duration string.\n" + }, + "scrapeTimeout": { + "type": "string", + "description": "Specifies the scrape timeout as duration string.\n" + }, + "targets": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getObservabilityScrapeconfigTarget:getObservabilityScrapeconfigTarget" + }, + "description": "The targets list (specified by the static config).\n" + } + }, + "type": "object", + "required": [ + "basicAuth", + "id", + "instanceId", + "metricsPath", + "name", + "projectId", + "saml2", + "sampleLimit", + "scheme", + "scrapeInterval", + "scrapeTimeout", + "targets" + ] + } + }, + "stackit:index/getOpensearchCredential:getOpensearchCredential": { + "description": "OpenSearch credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_opensearch_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getOpensearchCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getOpensearchCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "scheme": { + "type": "string" + }, + "uri": { + "type": "string", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "credentialId", + "host", + "hosts", + "id", + "instanceId", + "password", + "port", + "projectId", + "scheme", + "uri", + "username" + ] + } + }, + "stackit:index/getOpensearchInstance:getOpensearchInstance": { + "description": "OpenSearch instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_opensearch_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getOpensearchInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getOpensearchInstance.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "id": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the OpenSearch instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/getOpensearchInstanceParameters:getOpensearchInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object", + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "id", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ] + } + }, + "stackit:index/getPostgresflexDatabase:getPostgresflexDatabase": { + "description": "Postgres Flex database resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_postgresflex_database\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n database_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getPostgresflexDatabase.\n", + "properties": { + "databaseId": { + "type": "string", + "description": "Database ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Postgres Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "databaseId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getPostgresflexDatabase.\n", + "properties": { + "databaseId": { + "type": "string", + "description": "Database ID.\n" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Postgres Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Database name.\n" + }, + "owner": { + "type": "string", + "description": "Username of the database owner.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "databaseId", + "id", + "instanceId", + "name", + "owner", + "projectId" + ] + } + }, + "stackit:index/getPostgresflexInstance:getPostgresflexInstance": { + "description": "Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_postgresflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getPostgresflexInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getPostgresflexInstance.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the PostgresFlex instance.\n" + }, + "backupSchedule": { + "type": "string" + }, + "flavor": { + "$ref": "#/types/stackit:index/getPostgresflexInstanceFlavor:getPostgresflexInstanceFlavor" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/getPostgresflexInstanceStorage:getPostgresflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object", + "required": [ + "acls", + "backupSchedule", + "flavor", + "id", + "instanceId", + "name", + "projectId", + "replicas", + "storage", + "version" + ] + } + }, + "stackit:index/getPostgresflexUser:getPostgresflexUser": { + "description": "Postgres Flex user data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_postgresflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n user_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getPostgresflexUser.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId", + "userId" + ] + }, + "outputs": { + "description": "A collection of values returned by getPostgresflexUser.\n", + "properties": { + "host": { + "type": "string" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the PostgresFlex instance.\n" + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "host", + "id", + "instanceId", + "port", + "projectId", + "roles", + "userId", + "username" + ] + } + }, + "stackit:index/getPublicIp:getPublicIp": { + "description": "Public IP resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_public_ip\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n public_ip_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getPublicIp.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "publicIpId" + ] + }, + "outputs": { + "description": "A collection of values returned by getPublicIp.\n", + "properties": { + "id": { + "type": "string" + }, + "ip": { + "type": "string", + "description": "The IP address.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "networkInterfaceId": { + "type": "string", + "description": "Associates the public IP with a network interface or a virtual IP (ID).\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the public IP is associated.\n" + }, + "publicIpId": { + "type": "string", + "description": "The public IP ID.\n" + } + }, + "type": "object", + "required": [ + "id", + "ip", + "labels", + "networkInterfaceId", + "projectId", + "publicIpId" + ] + } + }, + "stackit:index/getPublicIpRanges:getPublicIpRanges": { + "description": "A list of all public IP ranges that STACKIT uses.\n\n## Example Usage\n\n```terraform\ndata \"stackit_public_ip_ranges\" \"example\" {}\n```\n", + "outputs": { + "description": "A collection of values returned by getPublicIpRanges.\n", + "properties": { + "id": { + "type": "string" + }, + "publicIpRanges": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getPublicIpRangesPublicIpRange:getPublicIpRangesPublicIpRange" + }, + "description": "A list of all public IP ranges.\n" + } + }, + "type": "object", + "required": [ + "id", + "publicIpRanges" + ] + } + }, + "stackit:index/getRabbitmqCredential:getRabbitmqCredential": { + "description": "RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_rabbitmq_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getRabbitmqCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getRabbitmqCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "httpApiUri": { + "type": "string" + }, + "httpApiUris": { + "type": "array", + "items": { + "type": "string" + } + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "management": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "secret": true + }, + "uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "credentialId", + "host", + "hosts", + "httpApiUri", + "httpApiUris", + "id", + "instanceId", + "management", + "password", + "port", + "projectId", + "uri", + "uris", + "username" + ] + } + }, + "stackit:index/getRabbitmqInstance:getRabbitmqInstance": { + "description": "RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_rabbitmq_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getRabbitmqInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getRabbitmqInstance.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "id": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the RabbitMQ instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/getRabbitmqInstanceParameters:getRabbitmqInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object", + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "id", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ] + } + }, + "stackit:index/getRedisCredential:getRedisCredential": { + "description": "Redis credential data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_redis_credential\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n credential_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getRedisCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "credentialId", + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getRedisCredential.\n", + "properties": { + "credentialId": { + "type": "string", + "description": "The credential's ID.\n" + }, + "host": { + "type": "string" + }, + "hosts": { + "type": "array", + "items": { + "type": "string" + } + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "loadBalancedHost": { + "type": "string" + }, + "password": { + "type": "string", + "secret": true + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "uri": { + "type": "string", + "description": "Connection URI.\n", + "secret": true + }, + "username": { + "type": "string" + } + }, + "type": "object", + "required": [ + "credentialId", + "host", + "hosts", + "id", + "instanceId", + "loadBalancedHost", + "password", + "port", + "projectId", + "uri", + "username" + ] + } + }, + "stackit:index/getRedisInstance:getRedisInstance": { + "description": "Redis instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_redis_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getRedisInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getRedisInstance.\n", + "properties": { + "cfGuid": { + "type": "string" + }, + "cfOrganizationGuid": { + "type": "string" + }, + "cfSpaceGuid": { + "type": "string" + }, + "dashboardUrl": { + "type": "string" + }, + "id": { + "type": "string" + }, + "imageUrl": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Redis instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "parameters": { + "$ref": "#/types/stackit:index/getRedisInstanceParameters:getRedisInstanceParameters" + }, + "planId": { + "type": "string", + "description": "The selected plan ID.\n" + }, + "planName": { + "type": "string", + "description": "The selected plan name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "version": { + "type": "string", + "description": "The service version.\n" + } + }, + "type": "object", + "required": [ + "cfGuid", + "cfOrganizationGuid", + "cfSpaceGuid", + "dashboardUrl", + "id", + "imageUrl", + "instanceId", + "name", + "parameters", + "planId", + "planName", + "projectId", + "version" + ] + } + }, + "stackit:index/getResourcemanagerProject:getResourcemanagerProject": { + "description": "Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used.\n\n## Example Usage\n\n```terraform\ndata \"stackit_resourcemanager_project\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n container_id = \"example-container-abc123\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getResourcemanagerProject.\n", + "properties": { + "containerId": { + "type": "string", + "description": "Project container ID. Globally unique, user-friendly identifier.\n" + }, + "projectId": { + "type": "string", + "description": "Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project.\n" + } + }, + "type": "object" + }, + "outputs": { + "description": "A collection of values returned by getResourcemanagerProject.\n", + "properties": { + "containerId": { + "type": "string", + "description": "Project container ID. Globally unique, user-friendly identifier.\n" + }, + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}\n" + }, + "name": { + "type": "string", + "description": "Project name.\n" + }, + "parentContainerId": { + "type": "string", + "description": "Parent resource identifier. Both container ID (user-friendly) and UUID are supported\n" + }, + "projectId": { + "type": "string", + "description": "Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project.\n" + } + }, + "type": "object", + "required": [ + "id", + "labels", + "name", + "parentContainerId" + ] + } + }, + "stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance": { + "description": "Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_secretsmanager_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSecretsmanagerInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSecretsmanagerInstance.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation\n" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + } + }, + "type": "object", + "required": [ + "acls", + "id", + "instanceId", + "name", + "projectId" + ] + } + }, + "stackit:index/getSecretsmanagerUser:getSecretsmanagerUser": { + "description": "Secrets Manager user data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_secretsmanager_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n user_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSecretsmanagerUser.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "userId": { + "type": "string", + "description": "The user's ID.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId", + "userId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSecretsmanagerUser.\n", + "properties": { + "description": { + "type": "string", + "description": "A user chosen description to differentiate between multiple users. Can't be changed after creation.\n" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the Secrets Manager instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the instance is associated.\n" + }, + "userId": { + "type": "string", + "description": "The user's ID.\n" + }, + "username": { + "type": "string", + "description": "An auto-generated user name.\n" + }, + "writeEnabled": { + "type": "boolean", + "description": "If true, the user has writeaccess to the secrets engine.\n" + } + }, + "type": "object", + "required": [ + "description", + "id", + "instanceId", + "projectId", + "userId", + "username", + "writeEnabled" + ] + } + }, + "stackit:index/getSecurityGroup:getSecurityGroup": { + "description": "Security group datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_security_group\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n security_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSecurityGroup.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group is associated.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "securityGroupId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSecurityGroup.\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the security group.\n" + }, + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the security group.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group is associated.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "stateful": { + "type": "boolean", + "description": "Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server.\n" + } + }, + "type": "object", + "required": [ + "description", + "id", + "labels", + "name", + "projectId", + "securityGroupId", + "stateful" + ] + } + }, + "stackit:index/getSecurityGroupRule:getSecurityGroupRule": { + "description": "Security group datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_security_group_rule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n security_group_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n security_group_rule_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSecurityGroupRule.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group rule is associated.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "securityGroupRuleId": { + "type": "string", + "description": "The security group rule ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "securityGroupId", + "securityGroupRuleId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSecurityGroupRule.\n", + "properties": { + "description": { + "type": "string", + "description": "The description of the security group rule.\n" + }, + "direction": { + "type": "string", + "description": "The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`.\n" + }, + "etherType": { + "type": "string", + "description": "The ethertype which the rule should match.\n" + }, + "icmpParameters": { + "$ref": "#/types/stackit:index/getSecurityGroupRuleIcmpParameters:getSecurityGroupRuleIcmpParameters", + "description": "ICMP Parameters.\n" + }, + "id": { + "type": "string" + }, + "ipRange": { + "type": "string", + "description": "The remote IP range which the rule should match.\n" + }, + "portRange": { + "$ref": "#/types/stackit:index/getSecurityGroupRulePortRange:getSecurityGroupRulePortRange", + "description": "The range of ports.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the security group rule is associated.\n" + }, + "protocol": { + "$ref": "#/types/stackit:index/getSecurityGroupRuleProtocol:getSecurityGroupRuleProtocol", + "description": "The internet protocol which the rule should match.\n" + }, + "remoteSecurityGroupId": { + "type": "string", + "description": "The remote security group which the rule should match.\n" + }, + "securityGroupId": { + "type": "string", + "description": "The security group ID.\n" + }, + "securityGroupRuleId": { + "type": "string", + "description": "The security group rule ID.\n" + } + }, + "type": "object", + "required": [ + "description", + "direction", + "etherType", + "icmpParameters", + "id", + "ipRange", + "portRange", + "projectId", + "protocol", + "remoteSecurityGroupId", + "securityGroupId", + "securityGroupRuleId" + ] + } + }, + "stackit:index/getServer:getServer": { + "description": "Server datasource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_server\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServer.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the server is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "serverId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServer.\n", + "properties": { + "affinityGroup": { + "type": "string", + "description": "The affinity group the server is assigned to.\n" + }, + "availabilityZone": { + "type": "string", + "description": "The availability zone of the server.\n" + }, + "bootVolume": { + "$ref": "#/types/stackit:index/getServerBootVolume:getServerBootVolume", + "description": "The boot volume for the server\n" + }, + "createdAt": { + "type": "string", + "description": "Date-time when the server was created\n" + }, + "id": { + "type": "string" + }, + "imageId": { + "type": "string", + "description": "The image ID to be used for an ephemeral disk on the server.\n" + }, + "keypairName": { + "type": "string", + "description": "The name of the keypair used during server creation.\n" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "launchedAt": { + "type": "string", + "description": "Date-time when the server was launched\n" + }, + "machineType": { + "type": "string", + "description": "Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html)\n" + }, + "name": { + "type": "string", + "description": "The name of the server.\n" + }, + "networkInterfaces": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The IDs of network interfaces which should be attached to the server. Updating it will recreate the server.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the server is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID.\n" + }, + "updatedAt": { + "type": "string", + "description": "Date-time when the server was updated\n" + }, + "userData": { + "type": "string", + "description": "User data that is passed via cloud-init to the server.\n" + } + }, + "type": "object", + "required": [ + "affinityGroup", + "availabilityZone", + "bootVolume", + "createdAt", + "id", + "imageId", + "keypairName", + "labels", + "launchedAt", + "machineType", + "name", + "networkInterfaces", + "projectId", + "serverId", + "updatedAt", + "userData" + ] + } + }, + "stackit:index/getServerBackupSchedule:getServerBackupSchedule": { + "description": "Server backup schedule datasource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_server_backup_schedule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n backup_schedule_id = xxxxx\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServerBackupSchedule.\n", + "properties": { + "backupScheduleId": { + "type": "integer", + "description": "Backup schedule ID.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the backup schedule.\n" + } + }, + "type": "object", + "required": [ + "backupScheduleId", + "projectId", + "serverId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServerBackupSchedule.\n", + "properties": { + "backupProperties": { + "$ref": "#/types/stackit:index/getServerBackupScheduleBackupProperties:getServerBackupScheduleBackupProperties", + "description": "Backup schedule details for the backups.\n" + }, + "backupScheduleId": { + "type": "integer", + "description": "Backup schedule ID.\n" + }, + "enabled": { + "type": "boolean", + "description": "Is the backup schedule enabled or disabled.\n" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Backup schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the backup schedule.\n" + } + }, + "type": "object", + "required": [ + "backupProperties", + "backupScheduleId", + "enabled", + "id", + "name", + "projectId", + "rrule", + "serverId" + ] + } + }, + "stackit:index/getServerBackupSchedules:getServerBackupSchedules": { + "description": "Server backup schedules datasource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_server_backup_schedules\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServerBackupSchedules.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT Project ID (UUID) to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID (UUID) to which the backup schedule is associated.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "serverId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServerBackupSchedules.\n", + "properties": { + "id": { + "type": "string" + }, + "items": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getServerBackupSchedulesItem:getServerBackupSchedulesItem" + } + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID (UUID) to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID (UUID) to which the backup schedule is associated.\n" + } + }, + "type": "object", + "required": [ + "id", + "items", + "projectId", + "serverId" + ] + } + }, + "stackit:index/getServerUpdateSchedule:getServerUpdateSchedule": { + "description": "Server update schedule datasource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_server_update_schedule\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n update_schedule_id = xxxxx\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServerUpdateSchedule.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the update schedule.\n" + }, + "updateScheduleId": { + "type": "integer", + "description": "Update schedule ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "serverId", + "updateScheduleId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServerUpdateSchedule.\n", + "properties": { + "enabled": { + "type": "boolean", + "description": "Is the update schedule enabled or disabled.\n" + }, + "id": { + "type": "string" + }, + "maintenanceWindow": { + "type": "integer", + "description": "Maintenance window [1..24].\n" + }, + "name": { + "type": "string", + "description": "The schedule name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "rrule": { + "type": "string", + "description": "Update schedule described in `rrule` (recurrence rule) format.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID for the update schedule.\n" + }, + "updateScheduleId": { + "type": "integer", + "description": "Update schedule ID.\n" + } + }, + "type": "object", + "required": [ + "enabled", + "id", + "maintenanceWindow", + "name", + "projectId", + "rrule", + "serverId", + "updateScheduleId" + ] + } + }, + "stackit:index/getServerUpdateSchedules:getServerUpdateSchedules": { + "description": "Server update schedules datasource schema. Must have a `region` specified in the provider configuration.\n\n\u003e This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources.\n\n## Example Usage\n\n```terraform\ndata \"stackit_server_update_schedules\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n server_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServerUpdateSchedules.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT Project ID (UUID) to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID (UUID) to which the update schedule is associated.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "serverId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServerUpdateSchedules.\n", + "properties": { + "id": { + "type": "string" + }, + "items": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getServerUpdateSchedulesItem:getServerUpdateSchedulesItem" + } + }, + "projectId": { + "type": "string", + "description": "STACKIT Project ID (UUID) to which the server is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "serverId": { + "type": "string", + "description": "Server ID (UUID) to which the update schedule is associated.\n" + } + }, + "type": "object", + "required": [ + "id", + "items", + "projectId", + "serverId" + ] + } + }, + "stackit:index/getServiceAccount:getServiceAccount": { + "description": "Service account data source schema.\n\n## Example Usage\n\n```terraform\ndata \"stackit_service_account\" \"sa\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n email = \"sa01-8565oq1@sa.stackit.cloud\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getServiceAccount.\n", + "properties": { + "email": { + "type": "string", + "description": "Email of the service account.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account is associated.\n" + } + }, + "type": "object", + "required": [ + "email", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getServiceAccount.\n", + "properties": { + "email": { + "type": "string", + "description": "Email of the service account.\n" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string", + "description": "Name of the service account.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the service account is associated.\n" + } + }, + "type": "object", + "required": [ + "email", + "id", + "name", + "projectId" + ] + } + }, + "stackit:index/getSkeCluster:getSkeCluster": { + "description": "SKE Cluster data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_ske_cluster\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n name = \"example-name\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSkeCluster.\n", + "properties": { + "name": { + "type": "string", + "description": "The cluster name.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "name", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSkeCluster.\n", + "properties": { + "allowPrivilegedContainers": { + "type": "boolean", + "description": "DEPRECATED as of Kubernetes 1.25+\nFlag to specify if privileged mode for containers is enabled or not.\nThis should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs).\n", + "deprecationMessage": "Please remove this flag from your configuration when using Kubernetes version 1.25+." + }, + "egressAddressRanges": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster.\n" + }, + "extensions": { + "$ref": "#/types/stackit:index/getSkeClusterExtensions:getSkeClusterExtensions", + "description": "A single extensions block as defined below\n" + }, + "hibernations": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getSkeClusterHibernation:getSkeClusterHibernation" + }, + "description": "One or more hibernation block as defined below.\n" + }, + "id": { + "type": "string" + }, + "kubernetesVersion": { + "type": "string", + "description": "Kubernetes version. This field is deprecated, use `kubernetes_version_used` instead\n", + "deprecationMessage": "This field is always nil, use `kubernetes_version_used` to get the cluster kubernetes version. This field would cause errors when the cluster got a kubernetes version minor upgrade, either triggered by automatic or forceful updates." + }, + "kubernetesVersionMin": { + "type": "string", + "description": "The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetes_version_used` field.\n" + }, + "kubernetesVersionUsed": { + "type": "string", + "description": "Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15`\n" + }, + "maintenance": { + "$ref": "#/types/stackit:index/getSkeClusterMaintenance:getSkeClusterMaintenance", + "description": "A single maintenance block as defined below\n" + }, + "name": { + "type": "string", + "description": "The cluster name.\n" + }, + "network": { + "$ref": "#/types/stackit:index/getSkeClusterNetwork:getSkeClusterNetwork", + "description": "Network block as defined below.\n" + }, + "nodePools": { + "type": "array", + "items": { + "$ref": "#/types/stackit:index/getSkeClusterNodePool:getSkeClusterNodePool" + }, + "description": "One or more `node_pool` block as defined below.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the cluster is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "allowPrivilegedContainers", + "egressAddressRanges", + "extensions", + "hibernations", + "id", + "kubernetesVersion", + "kubernetesVersionMin", + "kubernetesVersionUsed", + "maintenance", + "name", + "network", + "nodePools", + "projectId" + ] + } + }, + "stackit:index/getSqlserverflexInstance:getSqlserverflexInstance": { + "description": "SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_sqlserverflex_instance\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSqlserverflexInstance.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSqlserverflexInstance.\n", + "properties": { + "acls": { + "type": "array", + "items": { + "type": "string" + }, + "description": "The Access Control List (ACL) for the SQLServer Flex instance.\n" + }, + "backupSchedule": { + "type": "string", + "description": "The backup schedule. Should follow the cron scheduling system format (e.g. \"0 0 * * *\").\n" + }, + "flavor": { + "$ref": "#/types/stackit:index/getSqlserverflexInstanceFlavor:getSqlserverflexInstanceFlavor" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "name": { + "type": "string", + "description": "Instance name.\n" + }, + "options": { + "$ref": "#/types/stackit:index/getSqlserverflexInstanceOptions:getSqlserverflexInstanceOptions", + "description": "Custom parameters for the SQLServer Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "replicas": { + "type": "integer" + }, + "storage": { + "$ref": "#/types/stackit:index/getSqlserverflexInstanceStorage:getSqlserverflexInstanceStorage" + }, + "version": { + "type": "string" + } + }, + "type": "object", + "required": [ + "acls", + "backupSchedule", + "flavor", + "id", + "instanceId", + "name", + "options", + "projectId", + "replicas", + "storage", + "version" + ] + } + }, + "stackit:index/getSqlserverflexUser:getSqlserverflexUser": { + "description": "SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_sqlserverflex_user\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n instance_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n user_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getSqlserverflexUser.\n", + "properties": { + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + } + }, + "type": "object", + "required": [ + "instanceId", + "projectId", + "userId" + ] + }, + "outputs": { + "description": "A collection of values returned by getSqlserverflexUser.\n", + "properties": { + "host": { + "type": "string" + }, + "id": { + "type": "string" + }, + "instanceId": { + "type": "string", + "description": "ID of the SQLServer Flex instance.\n" + }, + "port": { + "type": "integer" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the instance is associated.\n" + }, + "region": { + "type": "string", + "description": "The resource region. If not defined, the provider region is used.\n" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + }, + "description": "Database access levels for the user.\n" + }, + "userId": { + "type": "string", + "description": "User ID.\n" + }, + "username": { + "type": "string", + "description": "Username of the SQLServer Flex instance.\n" + } + }, + "type": "object", + "required": [ + "host", + "id", + "instanceId", + "port", + "projectId", + "roles", + "userId", + "username" + ] + } + }, + "stackit:index/getVolume:getVolume": { + "description": "Volume resource schema. Must have a `region` specified in the provider configuration.\n\n## Example Usage\n\n```terraform\ndata \"stackit_volume\" \"example\" {\n project_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n volume_id = \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"\n}\n```\n", + "inputs": { + "description": "A collection of arguments for invoking getVolume.\n", + "properties": { + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume is associated.\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "type": "object", + "required": [ + "projectId", + "volumeId" + ] + }, + "outputs": { + "description": "A collection of values returned by getVolume.\n", + "properties": { + "availabilityZone": { + "type": "string", + "description": "The availability zone of the volume.\n" + }, + "description": { + "type": "string", + "description": "The description of the volume.\n" + }, + "id": { + "type": "string" + }, + "labels": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "description": "Labels are key-value string pairs which can be attached to a resource container\n" + }, + "name": { + "type": "string", + "description": "The name of the volume.\n" + }, + "performanceClass": { + "type": "string", + "description": "The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29)\n" + }, + "projectId": { + "type": "string", + "description": "STACKIT project ID to which the volume is associated.\n" + }, + "serverId": { + "type": "string", + "description": "The server ID of the server to which the volume is attached to.\n" + }, + "size": { + "type": "integer", + "description": "The size of the volume in GB. It can only be updated to a larger value than the current size\n" + }, + "source": { + "$ref": "#/types/stackit:index/getVolumeSource:getVolumeSource", + "description": "The source of the volume. It can be either a volume, an image, a snapshot or a backup\n" + }, + "volumeId": { + "type": "string", + "description": "The volume ID.\n" + } + }, + "type": "object", + "required": [ + "availabilityZone", + "description", + "id", + "labels", + "name", + "performanceClass", + "projectId", + "serverId", + "size", + "source", + "volumeId" + ] + } + } + } +} \ No newline at end of file diff --git a/provider/cmd/pulumi-tfgen-stackit/main.go b/provider/cmd/pulumi-tfgen-stackit/main.go new file mode 100644 index 0000000..48dc003 --- /dev/null +++ b/provider/cmd/pulumi-tfgen-stackit/main.go @@ -0,0 +1,25 @@ +// Copyright 2016-2018, Pulumi Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/pf/tfgen" + stackit "github.com/stackitcloud/pulumi-stackit/provider" +) + +func main() { + // Modify the path to point to the new provider + tfgen.Main("stackit", stackit.Provider()) +} diff --git a/provider/go.mod b/provider/go.mod new file mode 100644 index 0000000..1f3a468 --- /dev/null +++ b/provider/go.mod @@ -0,0 +1,227 @@ +module github.com/stackitcloud/pulumi-stackit/provider + +go 1.24 + +toolchain go1.24.4 + +replace ( + github.com/hashicorp/terraform-plugin-sdk/v2 => github.com/pulumi/terraform-plugin-sdk/v2 v2.0.0-20250530111747-935112552988 + github.com/stackitcloud/terraform-provider-stackit/shim => ./shim +) + +require ( + github.com/pulumi/pulumi-terraform-bridge/pf v0.49.0 + github.com/pulumi/pulumi-terraform-bridge/v3 v3.110.0 + github.com/pulumi/pulumi/sdk/v3 v3.181.0 + github.com/stackitcloud/terraform-provider-stackit/shim v0.0.0 + +) + +require ( + cloud.google.com/go v0.112.1 // indirect + cloud.google.com/go/compute/metadata v0.6.0 // indirect + cloud.google.com/go/iam v1.1.6 // indirect + cloud.google.com/go/storage v1.39.1 // indirect + dario.cat/mergo v1.0.0 // indirect + github.com/BurntSushi/toml v1.2.1 // indirect + github.com/Masterminds/goutils v1.1.1 // indirect + github.com/Masterminds/semver v1.5.0 // indirect + github.com/Masterminds/semver/v3 v3.2.0 // indirect + github.com/Masterminds/sprig/v3 v3.2.3 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/ProtonMail/go-crypto v1.1.6 // indirect + github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect + github.com/agext/levenshtein v1.2.3 // indirect + github.com/apparentlymart/go-cidr v1.1.0 // indirect + github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect + github.com/armon/go-radix v1.0.0 // indirect + github.com/atotto/clipboard v0.1.4 // indirect + github.com/aws/aws-sdk-go v1.50.36 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect + github.com/bgentry/speakeasy v0.1.0 // indirect + github.com/blang/semver v3.5.1+incompatible // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.25.0 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect + github.com/cheggaaa/pb v1.0.29 // indirect + github.com/cloudflare/circl v1.6.1 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect + github.com/cyphar/filepath-securejoin v0.4.1 // indirect + github.com/deckarep/golang-set/v2 v2.5.0 // indirect + github.com/djherbis/times v1.5.0 // indirect + github.com/edsrzf/mmap-go v1.1.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect + github.com/ettle/strcase v0.1.1 // indirect + github.com/fatih/color v1.18.0 // indirect + github.com/felixge/httpsnoop v1.0.4 // indirect + github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect + github.com/go-git/go-billy/v5 v5.6.2 // indirect + github.com/go-git/go-git/v5 v5.16.0 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang-jwt/jwt/v5 v5.2.2 // indirect + github.com/golang/glog v1.2.4 // indirect + github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/s2a-go v0.1.7 // indirect + github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/googleapis/enterprise-certificate-proxy v0.3.2 // indirect + github.com/googleapis/gax-go/v2 v2.12.2 // indirect + github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 // indirect + github.com/hashicorp/errwrap v1.1.0 // indirect + github.com/hashicorp/go-cleanhttp v0.5.2 // indirect + github.com/hashicorp/go-cty v1.5.0 // indirect + github.com/hashicorp/go-getter v1.7.5 // indirect + github.com/hashicorp/go-hclog v1.6.3 // indirect + github.com/hashicorp/go-multierror v1.1.1 // indirect + github.com/hashicorp/go-plugin v1.6.3 // indirect + github.com/hashicorp/go-safetemp v1.0.0 // indirect + github.com/hashicorp/go-uuid v1.0.3 // indirect + github.com/hashicorp/go-version v1.7.0 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/hashicorp/hcl/v2 v2.23.0 // indirect + github.com/hashicorp/hil v0.0.0-20190212132231-97b3a9cdfa93 // indirect + github.com/hashicorp/logutils v1.0.0 // indirect + github.com/hashicorp/terraform-plugin-framework v1.15.0 // indirect + github.com/hashicorp/terraform-plugin-framework-validators v0.18.0 // indirect + github.com/hashicorp/terraform-plugin-go v0.28.0 // indirect + github.com/hashicorp/terraform-plugin-log v0.9.0 // indirect + github.com/hashicorp/terraform-plugin-sdk v1.8.0 // indirect + github.com/hashicorp/terraform-plugin-sdk/v2 v2.37.0 // indirect + github.com/hashicorp/terraform-registry-address v0.2.5 // indirect + github.com/hashicorp/terraform-svchost v0.1.1 // indirect + github.com/hashicorp/yamux v0.1.2 // indirect + github.com/huandu/xstrings v1.3.3 // indirect + github.com/iancoleman/strcase v0.3.0 // indirect + github.com/imdario/mergo v0.3.15 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/json-iterator/go v1.1.12 // indirect + github.com/kevinburke/ssh_config v1.2.0 // indirect + github.com/klauspost/compress v1.16.7 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-colorable v0.1.14 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.15 // indirect + github.com/mitchellh/cli v1.1.5 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/go-homedir v1.1.0 // indirect + github.com/mitchellh/go-ps v1.0.0 // indirect + github.com/mitchellh/go-testing-interface v1.14.1 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/mitchellh/hashstructure v1.0.0 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect + github.com/modern-go/reflect2 v1.0.2 // indirect + github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.2 // indirect + github.com/natefinch/atomic v1.0.1 // indirect + github.com/oklog/run v1.1.0 // indirect + github.com/olekukonko/tablewriter v0.0.5 // indirect + github.com/opentofu/registry-address v0.0.0-20230922120653-901b9ae4061a // indirect + github.com/opentracing/basictracer-go v1.1.0 // indirect + github.com/opentracing/opentracing-go v1.2.0 // indirect + github.com/pgavlin/fx v0.1.6 // indirect + github.com/pgavlin/goldmark v1.1.33-0.20200616210433-b5eb04559386 // indirect + github.com/pjbgf/sha1cd v0.3.2 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pkg/term v1.1.0 // indirect + github.com/posener/complete v1.2.3 // indirect + github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 // indirect + github.com/pulumi/esc v0.14.3 // indirect + github.com/pulumi/inflector v0.1.1 // indirect + github.com/pulumi/pulumi-java/pkg v1.12.0 // indirect + github.com/pulumi/pulumi-yaml v1.19.1 // indirect + github.com/pulumi/pulumi/pkg/v3 v3.175.0 // indirect + github.com/pulumi/schema-tools v0.1.2 // indirect + github.com/rivo/uniseg v0.4.4 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect + github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect + github.com/segmentio/asm v1.1.3 // indirect + github.com/segmentio/encoding v0.3.5 // indirect + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect + github.com/shopspring/decimal v1.3.1 // indirect + github.com/skeema/knownhosts v1.3.1 // indirect + github.com/spf13/afero v1.10.0 // indirect + github.com/spf13/cast v1.5.0 // indirect + github.com/spf13/cobra v1.9.1 // indirect + github.com/spf13/pflag v1.0.6 // indirect + github.com/stackitcloud/stackit-sdk-go/core v0.17.2 // indirect + github.com/stackitcloud/stackit-sdk-go/services/authorization v0.7.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/cdn v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/dns v0.15.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/git v0.5.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/iaas v0.24.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.4.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/logme v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/mariadb v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/modelserving v0.4.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/mongodbflex v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/objectstorage v1.2.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/observability v0.7.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/opensearch v0.23.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/postgresflex v1.1.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/rabbitmq v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/redis v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.16.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.12.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serverbackup v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serverupdate v1.1.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.8.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/ske v0.27.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex v1.2.0 // indirect + github.com/stackitcloud/terraform-provider-stackit v0.56.0 // indirect + github.com/teambition/rrule-go v1.8.2 // indirect + github.com/teekennedy/goldmark-markdown v0.3.0 // indirect + github.com/texttheater/golang-levenshtein v1.0.1 // indirect + github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect + github.com/uber/jaeger-lib v2.4.1+incompatible // indirect + github.com/ulikunitz/xz v0.5.10 // indirect + github.com/vmihailenco/msgpack v4.0.4+incompatible // indirect + github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect + github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect + github.com/xanzy/ssh-agent v0.3.3 // indirect + github.com/yuin/goldmark v1.7.4 // indirect + github.com/zclconf/go-cty v1.16.3 // indirect + go.opencensus.io v0.24.0 // indirect + go.opentelemetry.io/auto/sdk v1.1.0 // indirect + go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect + go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 // indirect + go.opentelemetry.io/otel v1.35.0 // indirect + go.opentelemetry.io/otel/metric v1.35.0 // indirect + go.opentelemetry.io/otel/trace v1.35.0 // indirect + go.uber.org/atomic v1.9.0 // indirect + golang.org/x/crypto v0.39.0 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.41.0 // indirect + golang.org/x/oauth2 v0.29.0 // indirect + golang.org/x/sync v0.15.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/term v0.32.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/time v0.5.0 // indirect + golang.org/x/tools v0.34.0 // indirect + google.golang.org/api v0.169.0 // indirect + google.golang.org/appengine v1.6.8 // indirect + google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20250324211829-b45e905df463 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect + google.golang.org/grpc v1.73.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + lukechampine.com/frand v1.4.2 // indirect +) diff --git a/provider/go.sum b/provider/go.sum new file mode 100644 index 0000000..4cba550 --- /dev/null +++ b/provider/go.sum @@ -0,0 +1,1564 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.112.1 h1:uJSeirPke5UNZHIb4SxfZklVSiWWVqW4oXlETwZziwM= +cloud.google.com/go v0.112.1/go.mod h1:+Vbu+Y1UU+I1rjmzeMOb/8RfkKJK2Gyxi1X6jJCZLo4= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute/metadata v0.6.0 h1:A6hENjEsCDtC1k8byVsgwvVcioamEHvZ4j01OwKxG9I= +cloud.google.com/go/compute/metadata v0.6.0/go.mod h1:FjyFAW1MW0C203CEOMDTu3Dk1FlqW3Rga40jzHL4hfg= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v1.1.6 h1:bEa06k05IO4f4uJonbB5iAgKTPpABy1ayxaIZV/GHVc= +cloud.google.com/go/iam v1.1.6/go.mod h1:O0zxdPeGBoFdWW3HWmBxJsk0pfvNM/p/qa82rWOGTwI= +cloud.google.com/go/kms v1.15.7 h1:7caV9K3yIxvlQPAcaFffhlT7d1qpxjB1wHBtjWa13SM= +cloud.google.com/go/kms v1.15.7/go.mod h1:ub54lbsa6tDkUwnu4W7Yt1aAIFLnspgh0kPGToDukeI= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/logging v1.9.0 h1:iEIOXFO9EmSiTjDmfpbRjOxECO7R8C7b8IXUGOj7xZw= +cloud.google.com/go/logging v1.9.0/go.mod h1:1Io0vnZv4onoUnsVUQY3HZ3Igb1nBchky0A0y7BBBhE= +cloud.google.com/go/longrunning v0.5.5 h1:GOE6pZFdSrTb4KAiKnXsJBtlE6mEyaW44oKyMILWnOg= +cloud.google.com/go/longrunning v0.5.5/go.mod h1:WV2LAxD8/rg5Z1cNW6FJ/ZpX4E4VnDnoTk0yawPBB7s= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storage v1.39.1 h1:MvraqHKhogCOTXTlct/9C3K3+Uy2jBmFYb3/Sp6dVtY= +cloud.google.com/go/storage v1.39.1/go.mod h1:xK6xZmxZmo+fyP7+DEF6FhNc24/JAe95OLyOHCXFH1o= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0 h1:g0EZJwz7xkXQiZAI5xi9f3WWFYBlX1CPTrR+NDToRkQ= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0/go.mod h1:XCW7KnZet0Opnr7HccfUw1PLc4CjHqpcaxW8DHklNkQ= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.2 h1:F0gBpfdPLGsw+nsgk6aqqkZS1jiixa5WwFe3fk/T3Ys= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.8.2/go.mod h1:SqINnQ9lVVdRlyC8cd1lCI0SdX4n2paeABd2K8ggfnE= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0 h1:ywEEhmNahHBihViHepv3xPBn1663uRv2t2q/ESv9seY= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.10.0/go.mod h1:iZDifYGJTIgIIkYRNWPENUnqx6bJ2xnSDFI2tjwZNuY= +github.com/Azure/azure-sdk-for-go/sdk/keyvault/azkeys v0.10.0 h1:m/sWOGCREuSBqg2htVQTBY8nOZpyajYztF0vUvSZTuM= +github.com/Azure/azure-sdk-for-go/sdk/keyvault/azkeys v0.10.0/go.mod h1:Pu5Zksi2KrU7LPbZbNINx6fuVrUp/ffvpxdDj+i8LeE= +github.com/Azure/azure-sdk-for-go/sdk/keyvault/internal v0.7.1 h1:FbH3BbSb4bvGluTesZZ+ttN/MDsnMmQP36OSnDuSXqw= +github.com/Azure/azure-sdk-for-go/sdk/keyvault/internal v0.7.1/go.mod h1:9V2j0jn9jDEkCkv8w/bKTNppX/d0FVA1ud77xCIP4KA= +github.com/AzureAD/microsoft-authentication-library-for-go v1.3.3 h1:H5xDQaE3XowWfhZRUpnfC+rGZMEVoSiji+b+/HFAPU4= +github.com/AzureAD/microsoft-authentication-library-for-go v1.3.3/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= +github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/HdrHistogram/hdrhistogram-go v1.1.2 h1:5IcZpTvzydCQeHzK4Ef/D5rrSqwxob0t8PQPMybUNFM= +github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= +github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI= +github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU= +github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3QEww= +github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y= +github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs= +github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= +github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= +github.com/Masterminds/sprig/v3 v3.2.1/go.mod h1:UoaO7Yp8KlPnJIYWTFkMaqPUYKTfGFPhxNuwnnxkKlk= +github.com/Masterminds/sprig/v3 v3.2.3 h1:eL2fZNezLomi0uOLqjQoN6BfsDD+fyLtgbJMAj9n6YA= +github.com/Masterminds/sprig/v3 v3.2.3/go.mod h1:rXcFaZ2zZbLRJv/xSysmlgIM1u11eBaRMhvYXJNkGuM= +github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/ProtonMail/go-crypto v1.1.6 h1:ZcV+Ropw6Qn0AX9brlQLAUXfqLBc7Bl+f/DmNxpLfdw= +github.com/ProtonMail/go-crypto v1.1.6/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA= +github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/agext/levenshtein v1.2.2/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo= +github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412/go.mod h1:WPjqKcmVOxf0XSf3YxCJs6N6AOSrOx3obionmG7T0y0= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/apparentlymart/go-cidr v1.0.1/go.mod h1:EBcsNrHc3zQeuaeCeCtQruQm+n9/YjEn/vI25Lg7Gwc= +github.com/apparentlymart/go-cidr v1.1.0 h1:2mAhrMoF+nhXqxTzSZMUzDHkLjmIHC+Zzn4tdgBZjnU= +github.com/apparentlymart/go-cidr v1.1.0/go.mod h1:EBcsNrHc3zQeuaeCeCtQruQm+n9/YjEn/vI25Lg7Gwc= +github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM= +github.com/apparentlymart/go-dump v0.0.0-20190214190832-042adf3cf4a0/go.mod h1:oL81AME2rN47vu18xqj1S1jPIPuN7afo62yKTNn3XMM= +github.com/apparentlymart/go-textseg v1.0.0/go.mod h1:z96Txxhf3xSFMPmb5X/1W05FF/Nj9VFpLOpjS5yuumk= +github.com/apparentlymart/go-textseg/v12 v12.0.0/go.mod h1:S/4uRK2UtaQttw1GenVJEynmyUenKwP++x/+DdGV/Ec= +github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY= +github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI= +github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= +github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM= +github.com/aws/aws-sdk-go v1.25.3/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= +github.com/aws/aws-sdk-go v1.44.122/go.mod h1:y4AeaBuwd2Lk+GepC1E9v0qOiTws0MIWAX4oIKwKHZo= +github.com/aws/aws-sdk-go v1.50.36 h1:PjWXHwZPuTLMR1NIb8nEjLucZBMzmf84TLoLbD8BZqk= +github.com/aws/aws-sdk-go v1.50.36/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go-v2 v1.26.1 h1:5554eUqIYVWpU0YmeeYZ0wU64H2VLBs8TlhRB2L+EkA= +github.com/aws/aws-sdk-go-v2 v1.26.1/go.mod h1:ffIFB97e2yNsv4aTSGkqtHnppsIJzw7G7BReUZ3jCXM= +github.com/aws/aws-sdk-go-v2/config v1.27.11 h1:f47rANd2LQEYHda2ddSCKYId18/8BhSRM4BULGmfgNA= +github.com/aws/aws-sdk-go-v2/config v1.27.11/go.mod h1:SMsV78RIOYdve1vf36z8LmnszlRWkwMQtomCAI0/mIE= +github.com/aws/aws-sdk-go-v2/credentials v1.17.11 h1:YuIB1dJNf1Re822rriUOTxopaHHvIq0l/pX3fwO+Tzs= +github.com/aws/aws-sdk-go-v2/credentials v1.17.11/go.mod h1:AQtFPsDH9bI2O+71anW6EKL+NcD7LG3dpKGMV4SShgo= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1 h1:FVJ0r5XTHSmIHJV6KuDmdYhEpvlHpiSd38RQWhut5J4= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.1/go.mod h1:zusuAeqezXzAB24LGuzuekqMAEgWkVYukBec3kr3jUg= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 h1:aw39xVGeRWlWx9EzGVnhOR4yOjQDHPQ6o6NmBlscyQg= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5/go.mod h1:FSaRudD0dXiMPK2UjknVwwTYyZMRsHv3TtkabsZih5I= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 h1:PG1F3OD1szkuQPzDw3CIQsRIrtTlUC3lP84taWzHlq0= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5/go.mod h1:jU1li6RFryMz+so64PpKtudI+QzbKoIEivqdf6LNpOc= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2 h1:Ji0DY1xUsUr3I8cHps0G+XM3WWU16lP6yG8qu1GAZAs= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.2/go.mod h1:5CsjAbs3NlGQyZNFACh+zztPDI7fU6eW9QsxjfnuBKg= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7 h1:ogRAwT1/gxJBcSWDMZlgyFUM962F51A5CRhDLbxLdmo= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.7/go.mod h1:YCsIZhXfRPLFFCl5xxY+1T9RKzOKjCut+28JSX2DnAk= +github.com/aws/aws-sdk-go-v2/service/kms v1.30.1 h1:SBn4I0fJXF9FYOVRSVMWuhvEKoAHDikjGpS3wlmw5DE= +github.com/aws/aws-sdk-go-v2/service/kms v1.30.1/go.mod h1:2snWQJQUKsbN66vAawJuOGX7dr37pfOq9hb0tZDGIqQ= +github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 h1:vN8hEbpRnL7+Hopy9dzmRle1xmDc7o8tmY0klsr175w= +github.com/aws/aws-sdk-go-v2/service/sso v1.20.5/go.mod h1:qGzynb/msuZIE8I75DVRCUXw3o3ZyBmUvMwQ2t/BrGM= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 h1:Jux+gDDyi1Lruk+KHF91tK2KCuY61kzoCpvtvJJBtOE= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4/go.mod h1:mUYPBhaF2lGiukDEjJX2BLRRKTmoUSitGDUgM4tRxak= +github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 h1:cwIxeBttqPN3qkaAjcEcsh8NYr8n2HZPkcKgPAi1phU= +github.com/aws/aws-sdk-go-v2/service/sts v1.28.6/go.mod h1:FZf1/nKNEkHdGGJP/cI2MoIMquumuRK6ol3QQJNDxmw= +github.com/aws/smithy-go v1.20.2 h1:tbp628ireGtzcHDDmLT/6ADHidqnwgF57XOXZe6tp4Q= +github.com/aws/smithy-go v1.20.2/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas= +github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4= +github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY= +github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= +github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/bufbuild/protocompile v0.4.0 h1:LbFKd2XowZvQ/kajzguUp2DC9UEIQhIq77fZZlaQsNA= +github.com/bufbuild/protocompile v0.4.0/go.mod h1:3v93+mbWn/v3xzN+31nwkJfrEpAUwp+BagBSZWx+TP8= +github.com/cenkalti/backoff/v3 v3.2.2 h1:cfUAAO3yvKMYKPrvhDuHSwQnhZNk/RMHKdZqKTxfm6M= +github.com/cenkalti/backoff/v3 v3.2.2/go.mod h1:cIeZDE3IrqwwJl6VUwCN6trj1oXrTS4rc0ij+ULvLYs= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.25.0 h1:bAfwk7jRz7FKFl9RzlIULPkStffg5k6pNt5dywy4TcM= +github.com/charmbracelet/bubbletea v0.25.0/go.mod h1:EN3QDR1T5ZdWmdfDzYcqOCAps45+QIJbLOBxmVNWNNg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= +github.com/cheggaaa/pb v1.0.27/go.mod h1:pQciLPpbU0oxA0h+VJYYLxO+XeDQb5pZijXscXHm81s= +github.com/cheggaaa/pb v1.0.29 h1:FckUN5ngEk2LpvuG0fw1GEFx6LtyY2pWI/Z2QgCnEYo= +github.com/cheggaaa/pb v1.0.29/go.mod h1:W40334L7FMC5JKWldsTWbdGjLo0RxUKK73K+TuPxX30= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0= +github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= +github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/cyphar/filepath-securejoin v0.4.1 h1:JyxxyPEaktOD+GAnqIqTf9A8tHyAG22rowi7HkoSU1s= +github.com/cyphar/filepath-securejoin v0.4.1/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.5.0 h1:hn6cEZtQ0h3J8kFrHR/NrzyOoTnjgW1+FmNJzQ7y/sA= +github.com/deckarep/golang-set/v2 v2.5.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/djherbis/times v1.5.0 h1:79myA211VwPhFTqUk8xehWrsEO+zcIZj0zT8mXPVARU= +github.com/djherbis/times v1.5.0/go.mod h1:5q7FDLvbNg1L/KaBmPcWlVR9NmoKo3+ucqUA3ijQhA0= +github.com/edsrzf/mmap-go v1.1.0 h1:6EUwBLQ/Mcr1EYLE4Tn1VdW1A4ckqCQWZBw8Hr0kjpQ= +github.com/edsrzf/mmap-go v1.1.0/go.mod h1:19H/e8pUPLicwkyNgOykDXkJ9F0MHE+Z52B8EIth78Q= +github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= +github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= +github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/ettle/strcase v0.1.1 h1:htFueZyVeE1XNnMEfbqp5r67qAN/4r6ya1ysq8Q+Zcw= +github.com/ettle/strcase v0.1.1/go.mod h1:hzDLsPC7/lwKyBOywSHEP89nt2pDgdy+No1NBA9o9VY= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= +github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= +github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM= +github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= +github.com/go-git/go-git/v5 v5.16.0 h1:k3kuOEpkc0DeY7xlL6NaaNg39xdgQbtH5mwCafHO9AQ= +github.com/go-git/go-git/v5 v5.16.0/go.mod h1:4Ge4alE/5gPs30F2H1esi2gPd69R0C39lolkucHBOp8= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-jose/go-jose/v3 v3.0.4 h1:Wp5HA7bLQcKnf6YYao/4kpRpVMp/yf6+pJKV8WFSaNY= +github.com/go-jose/go-jose/v3 v3.0.4/go.mod h1:5b+7YgP7ZICgJDBdfjZaIt+H/9L9T/YQrVfLAMboGkQ= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68= +github.com/go-test/deep v1.0.3/go.mod h1:wGDj63lr65AM2AQyKZd/NYHGb0R+1RLqB8NKt3aSFNA= +github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0= +github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8= +github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.2.4 h1:CNNw5U8lSiiBk7druxtSHHTsRWcxKoac6kZKm2peBBc= +github.com/golang/glog v1.2.4/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 h1:f+oWsMOmNPc8JmEHVZIycC7hBoQxHH9pNKQORJNozsQ= +github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8/go.mod h1:wcDNUvekVysuuOpQKo3191zZyTpiI6se1N1ULghS0sw= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= +github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= +github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible h1:/CP5g8u/VJHijgedC/Legn3BAbAaWPgecwXBIDzw5no= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/martian/v3 v3.3.2 h1:IqNFLAmvJOgVlpdEBiQbDc2EwKW77amAycfTuWKdfvw= +github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= +github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= +github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/wire v0.6.0 h1:HBkoIh4BdSxoyo9PveV8giw7ZsaBOvzWKfcg/6MrVwI= +github.com/google/wire v0.6.0/go.mod h1:F4QhpQ9EDIdJ1Mbop/NZBRB+5yrR6qg3BnctaoUk6NA= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= +github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= +github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.12.2 h1:mhN09QQW1jEWeMF74zGR81R30z4VJzjZsfkUhuHF+DA= +github.com/googleapis/gax-go/v2 v2.12.2/go.mod h1:61M8vcyyXR2kqKFxKrfA22jaA8JGF7Dc8App1U3H6jc= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= +github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 h1:MJG/KsmcqMwFAkh8mTnAwhyKoB+sTAnY4CACC110tbU= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-cty v1.5.0 h1:EkQ/v+dDNUqnuVpmS5fPqyY71NXVgT5gf32+57xY8g0= +github.com/hashicorp/go-cty v1.5.0/go.mod h1:lFUCG5kd8exDobgSfyj4ONE/dc822kiYMguVKdHGMLM= +github.com/hashicorp/go-getter v1.4.0/go.mod h1:7qxyCd8rBfcShwsvxgIguu4KbS3l8bUCwg2Umn7RjeY= +github.com/hashicorp/go-getter v1.7.5 h1:dT58k9hQ/vbxNMwoI5+xFYAJuv6152UNvdHokfI5wE4= +github.com/hashicorp/go-getter v1.7.5/go.mod h1:W7TalhMmbPmsSMdNjD0ZskARur/9GJ17cfHTRtXV744= +github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd/go.mod h1:9bjs9uLqI8l75knNv3lV1kA55veR+WUPSiKIWcQHudI= +github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ= +github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= +github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hashicorp/go-plugin v1.0.1/go.mod h1:++UyYGoz3o5w9ZzAdZxtQKrWWP+iqPBn3cQptSMzBuY= +github.com/hashicorp/go-plugin v1.6.3 h1:xgHB+ZUSYeuJi96WtxEjzi23uh7YQpznjGh0U0UUrwg= +github.com/hashicorp/go-plugin v1.6.3/go.mod h1:MRobyh+Wc/nYy1V4KAXUiYfzxoYhs7V1mlH1Z7iY2h0= +github.com/hashicorp/go-retryablehttp v0.7.7 h1:C8hUCYzor8PIfXHa4UrZkU4VvK8o9ISHxT2Q8+VepXU= +github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk= +github.com/hashicorp/go-rootcerts v1.0.2 h1:jzhAVGtqPKbwpyCPELlgNWhE1znq+qwJtW5Oi2viEzc= +github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= +github.com/hashicorp/go-safetemp v1.0.0 h1:2HR189eFNrjHQyENnQMMpCiBAsRxzbTMIgBhEyExpmo= +github.com/hashicorp/go-safetemp v1.0.0/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.8 h1:iBt4Ew4XEGLfh6/bPk4rSYmuZJGizr6/x/AEizP0CQc= +github.com/hashicorp/go-secure-stdlib/parseutil v0.1.8/go.mod h1:aiJI+PIApBRQG7FZTEBx5GiiX+HbOHilUdNxUZi4eV0= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2 h1:kes8mmyCpxJsI7FTwtzRqEy9CdjCtrXrXGuOpxEA7Ts= +github.com/hashicorp/go-secure-stdlib/strutil v0.1.2/go.mod h1:Gou2R9+il93BqX25LAKCLuM+y9U2T4hlwvT1yprcna4= +github.com/hashicorp/go-sockaddr v1.0.6 h1:RSG8rKU28VTUTvEKghe5gIhIQpv8evvNpnDEyqO4u9I= +github.com/hashicorp/go-sockaddr v1.0.6/go.mod h1:uoUUmtwU7n9Dv3O4SNLeFvg0SxQ3lyjsj6+CCykpaxI= +github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8= +github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-version v1.1.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/hcl v0.0.0-20170504190234-a4b07c25de5f/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hashicorp/hcl/v2 v2.0.0/go.mod h1:oVVDG71tEinNGYCxinCYadcmKU9bglqW9pV3txagJ90= +github.com/hashicorp/hcl/v2 v2.23.0 h1:Fphj1/gCylPxHutVSEOf2fBOh1VE4AuLV7+kbJf3qos= +github.com/hashicorp/hcl/v2 v2.23.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= +github.com/hashicorp/hil v0.0.0-20190212132231-97b3a9cdfa93 h1:T1Q6ag9tCwun16AW+XK3tAql24P4uTGUMIn1/92WsQQ= +github.com/hashicorp/hil v0.0.0-20190212132231-97b3a9cdfa93/go.mod h1:n2TSygSNwsLJ76m8qFXTSc7beTb+auJxYdqrnoqwZWE= +github.com/hashicorp/logutils v1.0.0 h1:dLEQVugN8vlakKOUE3ihGLTZJRB4j+M2cdTm/ORI65Y= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/terraform-config-inspect v0.0.0-20191115094559-17f92b0546e8/go.mod h1:p+ivJws3dpqbp1iP84+npOyAmTTOLMgCzrXd3GSdn/A= +github.com/hashicorp/terraform-json v0.4.0/go.mod h1:eAbqb4w0pSlRmdvl8fOyHAi/+8jnkVYN28gJkSJrLhU= +github.com/hashicorp/terraform-plugin-framework v1.15.0 h1:LQ2rsOfmDLxcn5EeIwdXFtr03FVsNktbbBci8cOKdb4= +github.com/hashicorp/terraform-plugin-framework v1.15.0/go.mod h1:hxrNI/GY32KPISpWqlCoTLM9JZsGH3CyYlir09bD/fI= +github.com/hashicorp/terraform-plugin-framework-validators v0.18.0 h1:OQnlOt98ua//rCw+QhBbSqfW3QbwtVrcdWeQN5gI3Hw= +github.com/hashicorp/terraform-plugin-framework-validators v0.18.0/go.mod h1:lZvZvagw5hsJwuY7mAY6KUz45/U6fiDR0CzQAwWD0CA= +github.com/hashicorp/terraform-plugin-go v0.28.0 h1:zJmu2UDwhVN0J+J20RE5huiF3XXlTYVIleaevHZgKPA= +github.com/hashicorp/terraform-plugin-go v0.28.0/go.mod h1:FDa2Bb3uumkTGSkTFpWSOwWJDwA7bf3vdP3ltLDTH6o= +github.com/hashicorp/terraform-plugin-log v0.9.0 h1:i7hOA+vdAItN1/7UrfBqBwvYPQ9TFvymaRGZED3FCV0= +github.com/hashicorp/terraform-plugin-log v0.9.0/go.mod h1:rKL8egZQ/eXSyDqzLUuwUYLVdlYeamldAHSxjUFADow= +github.com/hashicorp/terraform-plugin-sdk v1.8.0 h1:HE1p52nzcgz88hIJmapUnkmM9noEjV3QhTOLaua5XUA= +github.com/hashicorp/terraform-plugin-sdk v1.8.0/go.mod h1:OjgQmey5VxnPej/buEhe+YqKm0KNvV3QqU4hkqHqPCY= +github.com/hashicorp/terraform-plugin-test v1.2.0/go.mod h1:QIJHYz8j+xJtdtLrFTlzQVC0ocr3rf/OjIpgZLK56Hs= +github.com/hashicorp/terraform-registry-address v0.2.5 h1:2GTftHqmUhVOeuu9CW3kwDkRe4pcBDq0uuK5VJngU1M= +github.com/hashicorp/terraform-registry-address v0.2.5/go.mod h1:PpzXWINwB5kuVS5CA7m1+eO2f1jKb5ZDIxrOPfpnGkg= +github.com/hashicorp/terraform-svchost v0.0.0-20191011084731-65d371908596/go.mod h1:kNDNcF7sN4DocDLBkQYz73HGKwN1ANB1blq4lIYLYvg= +github.com/hashicorp/terraform-svchost v0.1.1 h1:EZZimZ1GxdqFRinZ1tpJwVxxt49xc/S52uzrw4x0jKQ= +github.com/hashicorp/terraform-svchost v0.1.1/go.mod h1:mNsjQfZyf/Jhz35v6/0LWcv26+X7JPS+buii2c9/ctc= +github.com/hashicorp/vault/api v1.12.0 h1:meCpJSesvzQyao8FCOgk2fGdoADAnbDu2WPJN1lDLJ4= +github.com/hashicorp/vault/api v1.12.0/go.mod h1:si+lJCYO7oGkIoNPAN8j3azBLTn9SjMGS+jFaHd1Cck= +github.com/hashicorp/yamux v0.0.0-20180604194846-3520598351bb/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM= +github.com/hashicorp/yamux v0.0.0-20181012175058-2f1d1f20f75d/go.mod h1:+NfK9FKeTrX5uv1uIXGdwYDTeHna2qgaIlx54MXqjAM= +github.com/hashicorp/yamux v0.1.2 h1:XtB8kyFOyHXYVFnwT5C3+Bdo8gArse7j2AQ0DA0Uey8= +github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns= +github.com/hexops/autogold v1.3.0 h1:IEtGNPxBeBu8RMn8eKWh/Ll9dVNgSnJ7bp/qHgMQ14o= +github.com/hexops/autogold v1.3.0/go.mod h1:d4hwi2rid66Sag+BVuHgwakW/EmaFr8vdTSbWDbrDRI= +github.com/hexops/autogold/v2 v2.2.1 h1:JPUXuZQGkcQMv7eeDXuNMovjfoRYaa0yVcm+F3voaGY= +github.com/hexops/autogold/v2 v2.2.1/go.mod h1:IJwxtUfj1BGLm0YsR/k+dIxYi6xbeLjqGke2bzcOTMI= +github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM= +github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg= +github.com/hexops/valast v1.4.4 h1:rETyycw+/L2ZVJHHNxEBgh8KUn+87WugH9MxcEv9PGs= +github.com/hexops/valast v1.4.4/go.mod h1:Jcy1pNH7LNraVaAZDLyv21hHg2WBv9Nf9FL6fGxU7o4= +github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/huandu/xstrings v1.3.3 h1:/Gcsuc1x8JVbJ9/rlye4xZnVAbEkGauT8lbebqcQws4= +github.com/huandu/xstrings v1.3.3/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= +github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= +github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA= +github.com/imdario/mergo v0.3.15 h1:M8XP7IuFNsqUx6VPK2P9OSmsYsI/YFaGil0uD21V3dM= +github.com/imdario/mergo v0.3.15/go.mod h1:WBLT9ZmE3lPoWsEzCh9LPo3TiwVN+ZKEjmz+hD27ysY= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/jhump/protoreflect v1.15.1 h1:HUMERORf3I3ZdX05WaQ6MIpd/NJ434hTp5YiKgfCL6c= +github.com/jhump/protoreflect v1.15.1/go.mod h1:jD/2GMKKE6OqX8qTjhADU1e6DShO+gavG9e0Q693nKo= +github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= +github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= +github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= +github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= +github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/keybase/go-crypto v0.0.0-20161004153544-93f5b35093ba/go.mod h1:ghbZscTyKdM07+Fw3KSi0hcJm+AlEUWj8QLlPtijN/M= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/klauspost/compress v1.15.11/go.mod h1:QPwzmACJjUTFsnSHH934V6woptycfrDDJnH7hvFVbGM= +github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= +github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= +github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= +github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/cli v1.1.5 h1:OxRIeJXpAMztws/XHlN2vu6imG5Dpq+j61AzAX5fLng= +github.com/mitchellh/cli v1.1.5/go.mod h1:v8+iFts2sPIKUV1ltktPXMCC8fumSKFItNcD2cLtRR4= +github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw= +github.com/mitchellh/copystructure v1.0.0/go.mod h1:SNtv71yrdKgLRyLFxmLdkAbkKEFWgYaq1OVrnRcwhnw= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc= +github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= +github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/go-testing-interface v1.14.1 h1:jrgshOhYAUVNMAJiKbEu7EqAwgJJ2JqpQmpLJOu07cU= +github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8= +github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= +github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= +github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= +github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/mitchellh/hashstructure v1.0.0 h1:ZkRJX1CyOoTkar7p/mLS5TZU4nJ1Rn/F8u9dGS02Q3Y= +github.com/mitchellh/hashstructure v1.0.0/go.mod h1:QjSHrPWS+BGUVBYkbTZWEnOh3G1DutKwClXU/ABz6AQ= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/mitchellh/reflectwalk v1.0.1/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= +github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= +github.com/natefinch/atomic v1.0.1 h1:ZPYKxkqQOx3KZ+RsbnP/YsgvxWQPGxjC0oBt2AhwV0A= +github.com/natefinch/atomic v1.0.1/go.mod h1:N/D/ELrljoqDyT3rZrsUmtsuzvHkeB/wWjHV22AZRbM= +github.com/nightlyone/lockfile v1.0.0 h1:RHep2cFKK4PonZJDdEl4GmkabuhbsRMgk/k3uAmxBiA= +github.com/nightlyone/lockfile v1.0.0/go.mod h1:rywoIealpdNse2r832aiD9jRk8ErCatROs6LzC841CI= +github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA= +github.com/oklog/run v1.1.0 h1:GEenZ1cK0+q0+wsJew9qUg/DyD8k3JzYsZAi5gYi2mA= +github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= +github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +github.com/opentofu/registry-address v0.0.0-20230922120653-901b9ae4061a h1:NyM/PPbc+kxxv2d4OKfE32C5fLtVTLceyg4YKKCYO9Y= +github.com/opentofu/registry-address v0.0.0-20230922120653-901b9ae4061a/go.mod h1:HzQhpVo/NJnGmN+7FPECCVCA5ijU7AUcvf39enBKYOc= +github.com/opentracing/basictracer-go v1.1.0 h1:Oa1fTSBvAl8pa3U+IJYqrKm0NALwH9OsgwOqDv4xJW0= +github.com/opentracing/basictracer-go v1.1.0/go.mod h1:V2HZueSJEp879yv285Aap1BS69fQMD+MNP1mRs6mBQc= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/pgavlin/fx v0.1.6 h1:r9jEg69DhNoCd3Xh0+5mIbdbS3PqWrVWujkY76MFRTU= +github.com/pgavlin/fx v0.1.6/go.mod h1:KWZJ6fqBBSh8GxHYqwYCf3rYE7Gp2p0N8tJp8xv9u9M= +github.com/pgavlin/fx/v2 v2.0.3 h1:ZBVklTFjxcWvBVPE+ti5qwnmTIQ0Gq6nuj3J5RKDtKk= +github.com/pgavlin/fx/v2 v2.0.3/go.mod h1:Cvnwqq0BopdHUJ7CU50h1XPeKrF4ZwdFj1nJLXbAjCE= +github.com/pgavlin/goldmark v1.1.33-0.20200616210433-b5eb04559386 h1:LoCV5cscNVWyK5ChN/uCoIFJz8jZD63VQiGJIRgr6uo= +github.com/pgavlin/goldmark v1.1.33-0.20200616210433-b5eb04559386/go.mod h1:MRxHTJrf9FhdfNQ8Hdeh9gmHevC9RJE/fu8M3JIGjoE= +github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= +github.com/pjbgf/sha1cd v0.3.2 h1:a9wb0bp1oC2TGwStyn0Umc/IGKQnEgF0vVaZ8QF8eo4= +github.com/pjbgf/sha1cd v0.3.2/go.mod h1:zQWigSxVmsHEZow5qaLtPYxpcKMMQpa09ixqBxuCS6A= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= +github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/pkg/term v1.1.0 h1:xIAAdCMh3QIAy+5FrE8Ad8XoDhEU4ufwbaSozViP9kk= +github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/posener/complete v1.2.1/go.mod h1:6gapUrK/U1TAN7ciCoNRIdVC5sbdBTUh1DKN0g6uH7E= +github.com/posener/complete v1.2.3 h1:NP0eAhjcjImqslEwo/1hq7gpajME0fTLTezBKDqfXqo= +github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 h1:vkHw5I/plNdTr435cARxCW6q9gc0S/Yxz7Mkd38pOb0= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231/go.mod h1:murToZ2N9hNJzewjHBgfFdXhZKjY3z5cYC1VXk+lbFE= +github.com/pulumi/esc v0.14.3 h1:Zli+9LiSDT/W+Fsfr8tITxCo+5wn969tLrE4KLv44G8= +github.com/pulumi/esc v0.14.3/go.mod h1:XnSxlt5NkmuAj304l/gK4pRErFbtqq6XpfX1tYT9Jbc= +github.com/pulumi/inflector v0.1.1 h1:dvlxlWtXwOJTUUtcYDvwnl6Mpg33prhK+7mzeF+SobA= +github.com/pulumi/inflector v0.1.1/go.mod h1:HUFCjcPTz96YtTuUlwG3i3EZG4WlniBvR9bd+iJxCUY= +github.com/pulumi/providertest v0.3.0 h1:Dv10aoFaNQBDRtK8cRbd2uk9vEhpC/NryN+0y7NX4/o= +github.com/pulumi/providertest v0.3.0/go.mod h1:aTxVfdxP/Pe0iPbokjBp99x0XaY4fkZB2CjIS5wysMs= +github.com/pulumi/pulumi-java/pkg v1.12.0 h1:T7yFnFr0bgqy6huVUANMyUeGO1/Y3r2CJJ6S5YQDQCU= +github.com/pulumi/pulumi-java/pkg v1.12.0/go.mod h1:g8QQjEgB5wTsZptyf1vbIcI/pgYEGJObnihAEgymkAo= +github.com/pulumi/pulumi-terraform-bridge/pf v0.49.0 h1:GJ20wQxz5dYbOWdDyDp1E3SuuTuLVdBpnp70FJ+VVpQ= +github.com/pulumi/pulumi-terraform-bridge/pf v0.49.0/go.mod h1:zDdNBSsrNhUxyeX1MrXr/O71DBpWMFZ8dGIGV0Pbj0c= +github.com/pulumi/pulumi-terraform-bridge/v3 v3.110.0 h1:dSrgT3BVGDtmFZtIyT1fyO3nJ7mFt4/WEoGXoiym0tQ= +github.com/pulumi/pulumi-terraform-bridge/v3 v3.110.0/go.mod h1:u/wPklZlf0stCHcpZBncPau9h8p5QoCwZeKEds/O0FM= +github.com/pulumi/pulumi-yaml v1.19.1 h1:Y92eTQv07p5RbbNj6s/54+ibdPgvndLJ2Lb1IjYffng= +github.com/pulumi/pulumi-yaml v1.19.1/go.mod h1:n1JTtfUXR1IWVJ86HvMvQglK5mrDeDduxsLifGW1WIA= +github.com/pulumi/pulumi/pkg/v3 v3.175.0 h1:MsL2cnpGWivS/DLZ7MbJr0zMNg4P+pUprCEXvGoKBd4= +github.com/pulumi/pulumi/pkg/v3 v3.175.0/go.mod h1:neGNOTNMYSGUrh/L8kiAgowHRoB/kMmmutPo8WcLzM4= +github.com/pulumi/pulumi/sdk/v3 v3.181.0 h1:6XeYlG/mymtutRXlggcCLtxqBJPGCHNUGgoj4mapZQw= +github.com/pulumi/pulumi/sdk/v3 v3.181.0/go.mod h1:YS7uQ+eoIV/Fco804Upv3jmz5pwo/MkLYmbGH3VgA9c= +github.com/pulumi/schema-tools v0.1.2 h1:Fd9xvUjgck4NA+7/jSk7InqCUT4Kj940+EcnbQKpfZo= +github.com/pulumi/schema-tools v0.1.2/go.mod h1:62lgj52Tzq11eqWTIaKd+EVyYAu5dEcDJxMhTjvMO/k= +github.com/pulumi/terraform-diff-reader v0.0.2 h1:kTE4nEXU3/SYXESvAIem+wyHMI3abqkI3OhJ0G04LLI= +github.com/pulumi/terraform-diff-reader v0.0.2/go.mod h1:sZ9FUzGO+yM41hsQHs/yIcj/Y993qMdBxBU5mpDmAfQ= +github.com/pulumi/terraform-plugin-sdk/v2 v2.0.0-20250530111747-935112552988 h1:1q4ldc10b50WNvzjx4DD/rkFfhIdK96Tz14TFEGdGso= +github.com/pulumi/terraform-plugin-sdk/v2 v2.0.0-20250530111747-935112552988/go.mod h1:QYmYnLfsosrxjCnGY1p9c7Zj6n9thnEE+7RObeYs3fA= +github.com/rhysd/go-fakeio v1.0.0 h1:+TjiKCOs32dONY7DaoVz/VPOdvRkPfBkEyUDIpM8FQY= +github.com/rhysd/go-fakeio v1.0.0/go.mod h1:joYxF906trVwp2JLrE4jlN7A0z6wrz8O6o1UjarbFzE= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= +github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/ryanuber/go-glob v1.0.0 h1:iQh3xXAumdQ+4Ufa5b25cRpC5TYKlno6hsv6Cb3pkBk= +github.com/ryanuber/go-glob v1.0.0/go.mod h1:807d1WSdnB0XRJzKNil9Om6lcp/3a0v4qIHxIXzX/Yc= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 h1:TToq11gyfNlrMFZiYujSekIsPd9AmsA2Bj/iv+s4JHE= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0/go.mod h1:FKdcjfQW6rpZSnxxUvEA5H/cDPdvJ/SZJQLWWXWGrZ0= +github.com/segmentio/asm v1.1.3 h1:WM03sfUOENvvKexOLp+pCqgb/WDjsi7EK8gIsICtzhc= +github.com/segmentio/asm v1.1.3/go.mod h1:Ld3L4ZXGNcSLRg4JBsZ3//1+f/TjYl0Mzen/DQy1EJg= +github.com/segmentio/encoding v0.3.5 h1:UZEiaZ55nlXGDL92scoVuw00RmiRCazIEmvPSbSvt8Y= +github.com/segmentio/encoding v0.3.5/go.mod h1:n0JeuIqEQrQoPDGsjo8UNd1iA0U8d8+oHAA4E3G3OxM= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= +github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/skeema/knownhosts v1.3.1 h1:X2osQ+RAjK76shCbvhHHHVl3ZlgDm8apHEHFqRjnBY8= +github.com/skeema/knownhosts v1.3.1/go.mod h1:r7KTdC8l4uxWRyK2TpQZ/1o5HaSzh06ePQNxPwTcfiY= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/spf13/afero v1.10.0 h1:EaGW2JJh15aKOejeuJ+wpFSHnbd7GE6Wvp3TsNhb6LY= +github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w= +github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU= +github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo= +github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0= +github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o= +github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/stackitcloud/stackit-sdk-go/core v0.17.2 h1:jPyn+i8rkp2hM80+hOg0B/1EVRbMt778Tr5RWyK1m2E= +github.com/stackitcloud/stackit-sdk-go/core v0.17.2/go.mod h1:8KIw3czdNJ9sdil9QQimxjR6vHjeINFrRv0iZ67wfn0= +github.com/stackitcloud/stackit-sdk-go/services/authorization v0.7.0 h1:VpONplkdlEh7Pf22+cNnnHH4bx+S9QI+z55XYRE74JY= +github.com/stackitcloud/stackit-sdk-go/services/authorization v0.7.0/go.mod h1:dJ19ZwFjp2bfC5ZobXV3vUdSpE3quUw3GuoFSKLpHIo= +github.com/stackitcloud/stackit-sdk-go/services/cdn v1.2.1 h1:u1cLLpnuReJb+bRc6FONX0rMJiPpAT66HjpqxvNfjGU= +github.com/stackitcloud/stackit-sdk-go/services/cdn v1.2.1/go.mod h1:yTZjDrpVbEuDMRcCK7PpXR1yz+O6NcNFAgxydT6eBYc= +github.com/stackitcloud/stackit-sdk-go/services/dns v0.15.1 h1:+7iIR5r2epGNkAcuERX4kEg1H8hz2yR9+/zLYqZR7Xk= +github.com/stackitcloud/stackit-sdk-go/services/dns v0.15.1/go.mod h1:xhAdw016dY/hVsLerlExSMocqCc872+S0y1CdV3jAjU= +github.com/stackitcloud/stackit-sdk-go/services/git v0.5.1 h1:xs8CMY7t8nULQvZr5+XZRs8yWw8YMVw+HfjcuMhieR4= +github.com/stackitcloud/stackit-sdk-go/services/git v0.5.1/go.mod h1:agI7SONeLR/IZL3TOgn1tDzfS63O2rWKQE8+huRjEzU= +github.com/stackitcloud/stackit-sdk-go/services/iaas v0.24.0 h1:aLlZmcsDHqqc7KPsevvs+W6EPZFT51u/dx5TcVQsE6g= +github.com/stackitcloud/stackit-sdk-go/services/iaas v0.24.0/go.mod h1:TaMx7kukGpRm0BkNCmS7u2x12q1pgfbD55DAnLIjOIQ= +github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.4.0 h1:Ef4SyTBjIkfwaws4mssa6AoK+OokHFtr7ZIflUpoXVE= +github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.4.0/go.mod h1:FiVhDlw9+yuTiUmnyGLn2qpsLW26w9OC4TS1y78czvg= +github.com/stackitcloud/stackit-sdk-go/services/logme v0.24.1 h1:hfnILDJGBwwqUIs4xt/7Jj4LBe+JsSdHy+Md2ynUg4Y= +github.com/stackitcloud/stackit-sdk-go/services/logme v0.24.1/go.mod h1:XjDMHhAQogFXsVR+o138CPYG1FOe0/Nl2Vm+fAgzx2A= +github.com/stackitcloud/stackit-sdk-go/services/mariadb v0.24.1 h1:7nN7ZCuWSbJMy5KqoOqSbp5JKIOvyuDqVRtxVvT1iyE= +github.com/stackitcloud/stackit-sdk-go/services/mariadb v0.24.1/go.mod h1:Pb8IEV5/jP8k75dVcN5cn3kP7PHTy/4KXXKpG76oj4U= +github.com/stackitcloud/stackit-sdk-go/services/modelserving v0.4.1 h1:0ykRmxBW9W+Q4cXeXxL9nlaxmRBZ7/JvkH91DE/Spzs= +github.com/stackitcloud/stackit-sdk-go/services/modelserving v0.4.1/go.mod h1:3p68DR66MNYgc2YcMF7B23MmySVShQ6g7f+7EkZfpPY= +github.com/stackitcloud/stackit-sdk-go/services/mongodbflex v1.2.1 h1:TWz7qJ4Mg5pquDXODSZ1dzhS95ZYn3w1aKjuRU2VqCg= +github.com/stackitcloud/stackit-sdk-go/services/mongodbflex v1.2.1/go.mod h1:U1Zf/S9IuDvRJq1tRKFT/bsJd4qxYzwtukqX3TL++Mw= +github.com/stackitcloud/stackit-sdk-go/services/objectstorage v1.2.0 h1:+dKIPVz9ydKbX3x6+1NvYk++OA378w74p+N6SjDmzBQ= +github.com/stackitcloud/stackit-sdk-go/services/objectstorage v1.2.0/go.mod h1:iCOYS9yICXQPyMAIdUGMqJDLY8HXKiVAdiMzO/mPvtA= +github.com/stackitcloud/stackit-sdk-go/services/observability v0.7.1 h1:6OObzh2zk7wg75zYstcj0kjOjaxWc4joqA6qdeo8DP4= +github.com/stackitcloud/stackit-sdk-go/services/observability v0.7.1/go.mod h1:+eNo7SEeVRuW7hgujSabSketScSUKGuC88UznPS+UTE= +github.com/stackitcloud/stackit-sdk-go/services/opensearch v0.23.1 h1:E6vCqPn1NiPHnbnvqLNQNz6a/cmeyRb5iA9cDUPtP58= +github.com/stackitcloud/stackit-sdk-go/services/opensearch v0.23.1/go.mod h1:ifKKKCWL1U435fXGQ375SPX+burtfg1I7EGZ58COzRA= +github.com/stackitcloud/stackit-sdk-go/services/postgresflex v1.1.0 h1:r29a9GoBLVw2VZSzdPftlIsE5t7shdxobwoT6NVUIjU= +github.com/stackitcloud/stackit-sdk-go/services/postgresflex v1.1.0/go.mod h1:4g/L5PHfz1xk3udEhvPy2nXiH4UgRO5Cj6iwUa7k5VQ= +github.com/stackitcloud/stackit-sdk-go/services/rabbitmq v0.24.1 h1:2rDFwJtZOFYFUiJqJ9uIwM+mu+BbtuVaUHARRJtrZPU= +github.com/stackitcloud/stackit-sdk-go/services/rabbitmq v0.24.1/go.mod h1:YL0l9l9xzJy2BmV+U9XkcXlQaHbE2KyA37GpGvBXIJ4= +github.com/stackitcloud/stackit-sdk-go/services/redis v0.24.1 h1:4H+GL4eLEO116Vlh0pe+udGGYnMohA8YhLW9KYGdEOc= +github.com/stackitcloud/stackit-sdk-go/services/redis v0.24.1/go.mod h1:PAQH8+1DDGc6uibvC3nDtfRLu8uxutIr25mPJvrCOy8= +github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.16.0 h1:y8QUHaEdprQJ3VJgOpTVT1nOyTByKsw6k6ccQBoe1wo= +github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.16.0/go.mod h1:TBvZpbCju0Zmq8GoS4CEtUg2MqtdqWrGeEAOXwkJNQo= +github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.12.0 h1:oGR3wRC0xfX2Itpwbh/SrT/k2fnmMSzvy2U9U2lDQPs= +github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.12.0/go.mod h1:iD7R3CNdLUDUyKP+lATsQy+V4QGMMOb15zPnNq4wnbs= +github.com/stackitcloud/stackit-sdk-go/services/serverbackup v1.2.1 h1:0Kro/2d0GnqhOFTYq/4r9HwjZB/aT2erC1nyNmI0lnk= +github.com/stackitcloud/stackit-sdk-go/services/serverbackup v1.2.1/go.mod h1:S/zLsdZvtPXDSYyl7h2GLHhsnVf6AzB96PdslPWevJI= +github.com/stackitcloud/stackit-sdk-go/services/serverupdate v1.1.0 h1:WJA2v8XCISdrcbnJXstsjVE+QAFVsDpfJHNp0ORe1Bc= +github.com/stackitcloud/stackit-sdk-go/services/serverupdate v1.1.0/go.mod h1:5F7/2BiKhrbvHD56mj5xR9qf8P0V2yMgeitmdIpQv4s= +github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.8.1 h1:01AIQQtHdJ96La6BPVTRp6SLiGe5LXF+JmDKXbt4ZX0= +github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.8.1/go.mod h1:t77MA8uyEU9KZd1On5JpnxI3xhVPKIS8WutStqvU8Cw= +github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.2.1 h1:h1TsWatlsexLeKdkb3L8chcxaXJOy/cLXctsRxhb4xg= +github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.2.1/go.mod h1:M4xZ2BnmROvLV2MrAP6A8o9BnyT0CkvpEcP8lBOfRs8= +github.com/stackitcloud/stackit-sdk-go/services/ske v0.27.0 h1:bwLmLXvtCl1XkPRP+YrXwfz+lBMaGWH/crlNbYtxeqE= +github.com/stackitcloud/stackit-sdk-go/services/ske v0.27.0/go.mod h1:V09NmPahuUiuZEogVPgxuVqqti0th5B7TVAjuiM09mE= +github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex v1.2.0 h1:WvPLO1c7oT/MWmCRTt7jRyxus2g3DIluIW5iAsUpSFM= +github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex v1.2.0/go.mod h1:CyYJqR0tZWs2r5bGz69j4bmvhxdsd4QLCm1Uf+LouB0= +github.com/stackitcloud/terraform-provider-stackit v0.56.0 h1:uWgyd6d6KLtVNpKKSUKerj23n2LSziDw7rR/s86E/uY= +github.com/stackitcloud/terraform-provider-stackit v0.56.0/go.mod h1:uZ7G5NJhByxEMtrkkRB1RD/tz3mtBp4QErjFDtyKoOw= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/teambition/rrule-go v1.8.2 h1:lIjpjvWTj9fFUZCmuoVDrKVOtdiyzbzc93qTmRVe/J8= +github.com/teambition/rrule-go v1.8.2/go.mod h1:Ieq5AbrKGciP1V//Wq8ktsTXwSwJHDD5mD/wLBGl3p4= +github.com/teekennedy/goldmark-markdown v0.3.0 h1:ik9/biVGCwGWFg8dQ3KVm2pQ/wiiG0whYiUcz9xH0W8= +github.com/teekennedy/goldmark-markdown v0.3.0/go.mod h1:kMhDz8La77A9UHvJGsxejd0QUflN9sS+QXCqnhmxmNo= +github.com/texttheater/golang-levenshtein v1.0.1 h1:+cRNoVrfiwufQPhoMzB6N0Yf/Mqajr6t1lOv8GyGE2U= +github.com/texttheater/golang-levenshtein v1.0.1/go.mod h1:PYAKrbF5sAiq9wd+H82hs7gNaen0CplQ9uvm6+enD/8= +github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o= +github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk= +github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg= +github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U= +github.com/ulikunitz/xz v0.5.5/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8= +github.com/ulikunitz/xz v0.5.10 h1:t92gobL9l3HE202wg3rlk19F6X+JOxl9BBrCCMYEYd8= +github.com/ulikunitz/xz v0.5.10/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= +github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/vmihailenco/msgpack v4.0.1+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI= +github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8= +github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= +github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g= +github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= +github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= +github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/yuin/goldmark v1.7.4 h1:BDXOHExt+A7gwPCJgPIIq7ENvceR7we7rOS9TNoLZeg= +github.com/yuin/goldmark v1.7.4/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E= +github.com/zclconf/go-cty v1.0.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s= +github.com/zclconf/go-cty v1.1.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s= +github.com/zclconf/go-cty v1.2.1/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8= +github.com/zclconf/go-cty v1.16.3 h1:osr++gw2T61A8KVYHoQiFbFd1Lh3JOCXc/jFLJXKTxk= +github.com/zclconf/go-cty v1.16.3/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE= +github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940 h1:4r45xpDWB6ZMSMNJFMOjqrGHynW3DIBuR2H9j0ug+Mo= +github.com/zclconf/go-cty-debug v0.0.0-20240509010212-0d6042c53940/go.mod h1:CmBdvvj3nqzfzJ6nTCIwDTPZ56aVGvDrmztiO5g3qrM= +github.com/zclconf/go-cty-yaml v1.0.1/go.mod h1:IP3Ylp0wQpYm50IHK8OZWKMu6sPJIUgKa8XhiVHura0= +github.com/zclconf/go-cty-yaml v1.0.3 h1:og/eOQ7lvA/WWhHGFETVWNduJM7Rjsv2RRpx1sdFMLc= +github.com/zclconf/go-cty-yaml v1.0.3/go.mod h1:9YLUH4g7lOhVWqUbctnVlZ5KLpg7JAprQNgxSZ1Gyxs= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= +go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg= +go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0/go.mod h1:Mjt1i1INqiaoZOMGR1RIUJN+i3ChKoFRqzrRQhlkbs0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.35.0 h1:xKWKPxrxB6OtMCbmMY021CqC45J+3Onta9MqjhnusiQ= +go.opentelemetry.io/otel v1.35.0/go.mod h1:UEqy8Zp11hpkUrL73gSlELM0DupHoiq72dR+Zqel/+Y= +go.opentelemetry.io/otel/metric v1.35.0 h1:0znxYu2SNyuMSQT4Y9WDWej0VpcsxkuklLa4/siN90M= +go.opentelemetry.io/otel/metric v1.35.0/go.mod h1:nKVFgxBZ2fReX6IlyW28MgZojkoAkJGaE8CpgeAU3oE= +go.opentelemetry.io/otel/sdk v1.35.0 h1:iPctf8iprVySXSKJffSS79eOjl9pvxV9ZqOWT0QejKY= +go.opentelemetry.io/otel/sdk v1.35.0/go.mod h1:+ga1bZliga3DxJ3CQGg3updiaAJoNECOgJREo9KHGQg= +go.opentelemetry.io/otel/sdk/metric v1.35.0 h1:1RriWBmCKgkeHEhM7a2uMjMUfP7MsOF5JpUCaEqEI9o= +go.opentelemetry.io/otel/sdk/metric v1.35.0/go.mod h1:is6XYCUMpcKi+ZsOvfluY5YstFnhW0BidkR+gL+qN+w= +go.opentelemetry.io/otel/trace v1.35.0 h1:dPpEfJu1sDIqruz7BHFG3c7528f6ddfSWfFDVt/xgMs= +go.opentelemetry.io/otel/trace v1.35.0/go.mod h1:WUk7DtFp1Aw2MkvqGdwiXYDZZNvA/1J8o6xRXLrIkyc= +go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +gocloud.dev v0.37.0 h1:XF1rN6R0qZI/9DYjN16Uy0durAmSlf58DHOcb28GPro= +gocloud.dev v0.37.0/go.mod h1:7/O4kqdInCNsc6LqgmuFnS0GRew4XNNYWpA44yQnwco= +gocloud.dev/secrets/hashivault v0.37.0 h1:5ehGtUBP29DFAgAs6bPw7fVSgqQ3TxaoK2xVcLp1x+c= +gocloud.dev/secrets/hashivault v0.37.0/go.mod h1:4ClUWjBfP8wLdGts56acjHz3mWLuATMoH9vi74FjIv8= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200414173820-0848c9571904/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.3.0/go.mod h1:hebNnKkNXi2UzZN1eVRvBB7co0a+JxK6XbPiWVs/3J4= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191009170851-d66e71096ffb/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw= +golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.1.0/go.mod h1:G9FE4dLTsbXUu90h/Pf85g4w1D+SSAgR+q46nJZ8M4A= +golang.org/x/oauth2 v0.29.0 h1:WdYw2tdTK1S8olAzWHdgeqfy+Mtm9XNhv/xJsY65d98= +golang.org/x/oauth2 v0.29.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8= +golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190129075346-302c3dd5f1cc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502175342-a43fa875dd82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190804053845-51ab0e2deafa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg= +golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo= +golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.169.0 h1:QwWPy71FgMWqJN/l6jVlFHUa29a7dcUy02I8o799nPY= +google.golang.org/api v0.169.0/go.mod h1:gpNOiMA2tZ4mf5R9Iwf4rK/Dcz0fbdIgWYWVoxmsyLg= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221025140454-527a21cfbd71/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7 h1:ImUcDPHjTrAqNhlOkSocDLfG9rrNHH7w7uoKWPaWZ8s= +google.golang.org/genproto v0.0.0-20240311173647-c811ad7063a7/go.mod h1:/3XmxOjePkvmKrHuBy4zNFw7IzxJXtAgdpXi8Ll990U= +google.golang.org/genproto/googleapis/api v0.0.0-20250324211829-b45e905df463 h1:hE3bRWtU6uceqlh4fhrSnUyjKHMKB9KrTLLG+bc0ddM= +google.golang.org/genproto/googleapis/api v0.0.0-20250324211829-b45e905df463/go.mod h1:U90ffi8eUL9MwPcrJylN5+Mk2v3vuPDptd5yyNUiRR8= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 h1:fc6jSaCT0vBduLYZHYrBBNY4dsWuvgyff9noRNDdBeE= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.73.0 h1:VIWSmpI2MegBtTuFt5/JWy2oXxtjJ/e89Z70ImfD2ok= +google.golang.org/grpc v1.73.0/go.mod h1:50sbHOUqWoCQGI8V2HQLJM0B+LMlIUjNSZmow7EVBQc= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/cheggaaa/pb.v1 v1.0.27/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= +gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU= +gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +lukechampine.com/frand v1.4.2 h1:RzFIpOvkMXuPMBb9maa4ND4wjBn71E1Jpf8BzJHMaVw= +lukechampine.com/frand v1.4.2/go.mod h1:4S/TM2ZgrKejMcKMbeLjISpJMO+/eZ1zu3vYX9dtj3s= +mvdan.cc/gofumpt v0.5.0 h1:0EQ+Z56k8tXjj/6TQD25BFNKQXpCvT0rnansIc7Ug5E= +mvdan.cc/gofumpt v0.5.0/go.mod h1:HBeVDtMKRZpXyxFciAirzdKklDlGu8aAy1wEbH5Y9js= +pgregory.net/rapid v0.6.1 h1:4eyrDxyht86tT4Ztm+kvlyNBLIk071gR+ZQdhphc9dQ= +pgregory.net/rapid v0.6.1/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= diff --git a/provider/pkg/version/version.go b/provider/pkg/version/version.go new file mode 100644 index 0000000..1d17f38 --- /dev/null +++ b/provider/pkg/version/version.go @@ -0,0 +1,18 @@ +// Copyright 2016-2018, Pulumi Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package version + +// Version is initialized by the Go linker to contain the semver of this build. +var Version string diff --git a/provider/resources.go b/provider/resources.go new file mode 100644 index 0000000..2601cb7 --- /dev/null +++ b/provider/resources.go @@ -0,0 +1,139 @@ +// Copyright 2016-2018, Pulumi Corporation. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// github.com/pulumi/pulumi-terraform-bridge/v3/pkg/pf/tfbridge.ShimProvide +package stackit + +import ( + _ "embed" + "fmt" + "path/filepath" + + pfbridge "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/pf/tfbridge" + "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfbridge" + tfbridgetokens "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfbridge/tokens" + "github.com/stackitcloud/pulumi-stackit/provider/pkg/version" + "github.com/stackitcloud/terraform-provider-stackit/shim" +) + +// all of the token components used below. +const ( + // This variable controls the default name of the package in the package + // registries for nodejs and python: + mainPkg = "stackit" + // modules: + mainMod = "index" // the stackit module +) + +//go:embed cmd/pulumi-resource-stackit/bridge-metadata.json +var metadata []byte + +// Provider returns additional overlaid schema and metadata associated with the provider.. +func Provider() tfbridge.ProviderInfo { + // Instantiate the Terraform provider + p := pfbridge.ShimProvider(shim.NewProvider()) + + // Create a Pulumi provider mapping + prov := tfbridge.ProviderInfo{ + P: p, + Version: version.Version, + Name: "stackit", + // DisplayName is a way to be able to change the casing of the provider + // name when being displayed on the Pulumi registry + DisplayName: "stackit", + // The default publisher for all packages is Pulumi. + // Change this to your personal name (or a company name) that you + // would like to be shown in the Pulumi Registry if this package is published + // there. + Publisher: "stackitcloud", + // LogoURL is optional but useful to help identify your package in the Pulumi Registry + // if this package is published there. + // + // You may host a logo on a domain you control or add an SVG logo for your package + // in your repository and use the raw content URL for that file as your logo URL. + LogoURL: "", + // PluginDownloadURL is an optional URL used to download the Provider + // for use in Pulumi programs + // e.g https://github.com/org/pulumi-provider-name/releases/ + PluginDownloadURL: "github://api.github.com/stackitcloud/pulumi-stackit", + Description: "A Pulumi package for creating and managing stackit resources.", + // category/cloud tag helps with categorizing the package in the Pulumi Registry. + // For all available categories, see `Keywords` in + // https://www.pulumi.com/docs/guides/pulumi-packages/schema/#package. + Keywords: []string{"pulumi", "stackit", "category/utility"}, + License: "Apache-2.0", + Homepage: "https://www.pulumi.com", + Repository: "https://github.com/stackitcloud/pulumi-stackit", + // The GitHub Org for the provider - defaults to `terraform-providers`. Note that this + // should match the TF provider module's require directive, not any replace directives. + GitHubOrg: "stackitcloud", + MetadataInfo: tfbridge.NewProviderMetadata(metadata), + Config: map[string]*tfbridge.SchemaInfo{ + // Add any required configuration here, or remove the example below if + // no additional points are required. + // "region": { + // Type: tfbridge.MakeType("region", "Region"), + // Default: &tfbridge.DefaultInfo{ + // EnvVars: []string{"AWS_REGION", "AWS_DEFAULT_REGION"}, + // }, + // }, + + }, + JavaScript: &tfbridge.JavaScriptInfo{ + PackageName: "@stackitcloud/pulumi-stackit", + // List any npm dependencies and their versions + Dependencies: map[string]string{ + "@pulumi/pulumi": "^3.0.0", + }, + DevDependencies: map[string]string{ + "@types/node": "^10.0.0", // so we can access strongly typed node definitions. + "@types/mime": "^2.0.0", + }, + // See the documentation for tfbridge.OverlayInfo for how to lay out this + // section, or refer to the AWS provider. Delete this section if there are + // no overlay files. + //Overlay: &tfbridge.OverlayInfo{}, + }, + Python: &tfbridge.PythonInfo{ + PackageName: "pulumi_stackit", + // List any Python dependencies and their version ranges + Requires: map[string]string{ + "pulumi": ">=3.0.0,<4.0.0", + }, + }, + Golang: &tfbridge.GolangInfo{ + ImportBasePath: filepath.Join( + fmt.Sprintf("github.com/stackitcloud/pulumi-%[1]s/sdk/", mainPkg), + tfbridge.GetModuleMajorVersion(version.Version), + "go", + mainPkg, + ), + GenerateResourceContainerTypes: true, + }, + CSharp: &tfbridge.CSharpInfo{ + PackageReferences: map[string]string{ + "Pulumi": "3.*", + }, + }, + } + + prov.MustComputeTokens(tfbridgetokens.SingleModule("stackit_", mainMod, + tfbridgetokens.MakeStandard(mainPkg))) + + prov.MustApplyAutoAliases() + + prov.SetAutonaming(255, "-") + + return prov +} diff --git a/provider/shim/go.mod b/provider/shim/go.mod new file mode 100644 index 0000000..1a515eb --- /dev/null +++ b/provider/shim/go.mod @@ -0,0 +1,89 @@ +module github.com/stackitcloud/terraform-provider-stackit/shim + +go 1.24 + +toolchain go1.24.2 + +require ( + github.com/hashicorp/terraform-plugin-sdk/v2 v2.37.0 + github.com/stackitcloud/terraform-provider-stackit v0.56.0 +) + +require ( + github.com/agext/levenshtein v1.2.3 // indirect + github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect + github.com/fatih/color v1.18.0 // indirect + github.com/golang-jwt/jwt/v5 v5.2.2 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/google/go-cmp v0.7.0 // indirect + github.com/google/go-querystring v1.1.0 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/hashicorp/go-cleanhttp v0.5.2 // indirect + github.com/hashicorp/go-cty v1.5.0 // indirect + github.com/hashicorp/go-hclog v1.6.3 // indirect + github.com/hashicorp/go-plugin v1.6.3 // indirect + github.com/hashicorp/go-retryablehttp v0.7.7 // indirect + github.com/hashicorp/go-uuid v1.0.3 // indirect + github.com/hashicorp/go-version v1.7.0 // indirect + github.com/hashicorp/hcl/v2 v2.23.0 // indirect + github.com/hashicorp/logutils v1.0.0 // indirect + github.com/hashicorp/terraform-plugin-framework v1.15.0 // indirect + github.com/hashicorp/terraform-plugin-framework-validators v0.18.0 // indirect + github.com/hashicorp/terraform-plugin-go v0.28.0 // indirect + github.com/hashicorp/terraform-plugin-log v0.9.0 // indirect + github.com/hashicorp/terraform-registry-address v0.2.5 // indirect + github.com/hashicorp/terraform-svchost v0.1.1 // indirect + github.com/hashicorp/yamux v0.1.2 // indirect + github.com/mattn/go-colorable v0.1.14 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/go-testing-interface v1.14.1 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/oklog/run v1.1.0 // indirect + github.com/stackitcloud/stackit-sdk-go/core v0.17.2 // indirect + github.com/stackitcloud/stackit-sdk-go/services/authorization v0.7.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/cdn v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/dns v0.15.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/git v0.5.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/iaas v0.24.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.4.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/logme v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/mariadb v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/modelserving v0.4.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/mongodbflex v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/objectstorage v1.2.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/observability v0.7.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/opensearch v0.23.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/postgresflex v1.1.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/rabbitmq v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/redis v0.24.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.16.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.12.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serverbackup v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serverupdate v1.1.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.8.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.2.1 // indirect + github.com/stackitcloud/stackit-sdk-go/services/ske v0.27.0 // indirect + github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex v1.2.0 // indirect + + github.com/stretchr/testify v1.9.0 // indirect + github.com/teambition/rrule-go v1.8.2 // indirect + github.com/vmihailenco/msgpack v4.0.4+incompatible // indirect + github.com/vmihailenco/msgpack/v5 v5.4.1 // indirect + github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect + github.com/zclconf/go-cty v1.16.3 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.41.0 // indirect + golang.org/x/oauth2 v0.29.0 // indirect + golang.org/x/sync v0.15.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/tools v0.34.0 // indirect + google.golang.org/appengine v1.6.8 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822 // indirect + google.golang.org/grpc v1.73.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect +) diff --git a/provider/shim/go.sum b/provider/shim/go.sum new file mode 100644 index 0000000..a1713ae --- /dev/null +++ b/provider/shim/go.sum @@ -0,0 +1,137 @@ +github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/apparentlymart/go-textseg/v12 v12.0.0/go.mod h1:S/4uRK2UtaQttw1GenVJEynmyUenKwP++x/+DdGV/Ec= +github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= +github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk= +github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-cty v1.5.0/go.mod h1:lFUCG5kd8exDobgSfyj4ONE/dc822kiYMguVKdHGMLM= +github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= +github.com/hashicorp/go-plugin v1.6.3/go.mod h1:MRobyh+Wc/nYy1V4KAXUiYfzxoYhs7V1mlH1Z7iY2h0= +github.com/hashicorp/go-retryablehttp v0.7.7/go.mod h1:pkQpWZeYWskR+D1tR2O5OcBFOxfA7DoAO6xtkuQnHTk= +github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/hcl/v2 v2.23.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/terraform-plugin-framework v1.15.0/go.mod h1:hxrNI/GY32KPISpWqlCoTLM9JZsGH3CyYlir09bD/fI= +github.com/hashicorp/terraform-plugin-framework-validators v0.18.0/go.mod h1:lZvZvagw5hsJwuY7mAY6KUz45/U6fiDR0CzQAwWD0CA= +github.com/hashicorp/terraform-plugin-go v0.28.0/go.mod h1:FDa2Bb3uumkTGSkTFpWSOwWJDwA7bf3vdP3ltLDTH6o= +github.com/hashicorp/terraform-plugin-log v0.9.0/go.mod h1:rKL8egZQ/eXSyDqzLUuwUYLVdlYeamldAHSxjUFADow= +github.com/hashicorp/terraform-plugin-sdk/v2 v2.37.0/go.mod h1:QYmYnLfsosrxjCnGY1p9c7Zj6n9thnEE+7RObeYs3fA= +github.com/hashicorp/terraform-registry-address v0.2.5/go.mod h1:PpzXWINwB5kuVS5CA7m1+eO2f1jKb5ZDIxrOPfpnGkg= +github.com/hashicorp/terraform-svchost v0.1.1/go.mod h1:mNsjQfZyf/Jhz35v6/0LWcv26+X7JPS+buii2c9/ctc= +github.com/hashicorp/yamux v0.1.2/go.mod h1:C+zze2n6e/7wshOZep2A70/aQU6QBRWJO/G6FT1wIns= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/go-testing-interface v1.14.1/go.mod h1:gfgS7OtZj6MA4U1UrDRp04twqAjfvlZyCfX3sDjEym8= +github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/oklog/run v1.1.0/go.mod h1:sVPdnTZT1zYwAJeCMu2Th4T21pA3FPOQRfWjQlk7DVU= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stackitcloud/stackit-sdk-go/core v0.17.2/go.mod h1:8KIw3czdNJ9sdil9QQimxjR6vHjeINFrRv0iZ67wfn0= +github.com/stackitcloud/stackit-sdk-go/services/authorization v0.7.0/go.mod h1:dJ19ZwFjp2bfC5ZobXV3vUdSpE3quUw3GuoFSKLpHIo= +github.com/stackitcloud/stackit-sdk-go/services/cdn v1.2.1/go.mod h1:yTZjDrpVbEuDMRcCK7PpXR1yz+O6NcNFAgxydT6eBYc= +github.com/stackitcloud/stackit-sdk-go/services/dns v0.15.1/go.mod h1:xhAdw016dY/hVsLerlExSMocqCc872+S0y1CdV3jAjU= +github.com/stackitcloud/stackit-sdk-go/services/git v0.5.1/go.mod h1:agI7SONeLR/IZL3TOgn1tDzfS63O2rWKQE8+huRjEzU= +github.com/stackitcloud/stackit-sdk-go/services/iaas v0.24.0/go.mod h1:TaMx7kukGpRm0BkNCmS7u2x12q1pgfbD55DAnLIjOIQ= +github.com/stackitcloud/stackit-sdk-go/services/loadbalancer v1.4.0/go.mod h1:FiVhDlw9+yuTiUmnyGLn2qpsLW26w9OC4TS1y78czvg= +github.com/stackitcloud/stackit-sdk-go/services/logme v0.24.1/go.mod h1:XjDMHhAQogFXsVR+o138CPYG1FOe0/Nl2Vm+fAgzx2A= +github.com/stackitcloud/stackit-sdk-go/services/mariadb v0.24.1/go.mod h1:Pb8IEV5/jP8k75dVcN5cn3kP7PHTy/4KXXKpG76oj4U= +github.com/stackitcloud/stackit-sdk-go/services/modelserving v0.4.1/go.mod h1:3p68DR66MNYgc2YcMF7B23MmySVShQ6g7f+7EkZfpPY= +github.com/stackitcloud/stackit-sdk-go/services/mongodbflex v1.2.1/go.mod h1:U1Zf/S9IuDvRJq1tRKFT/bsJd4qxYzwtukqX3TL++Mw= +github.com/stackitcloud/stackit-sdk-go/services/objectstorage v1.2.0/go.mod h1:iCOYS9yICXQPyMAIdUGMqJDLY8HXKiVAdiMzO/mPvtA= +github.com/stackitcloud/stackit-sdk-go/services/observability v0.7.1/go.mod h1:+eNo7SEeVRuW7hgujSabSketScSUKGuC88UznPS+UTE= +github.com/stackitcloud/stackit-sdk-go/services/opensearch v0.23.1/go.mod h1:ifKKKCWL1U435fXGQ375SPX+burtfg1I7EGZ58COzRA= +github.com/stackitcloud/stackit-sdk-go/services/postgresflex v1.1.0/go.mod h1:4g/L5PHfz1xk3udEhvPy2nXiH4UgRO5Cj6iwUa7k5VQ= +github.com/stackitcloud/stackit-sdk-go/services/rabbitmq v0.24.1/go.mod h1:YL0l9l9xzJy2BmV+U9XkcXlQaHbE2KyA37GpGvBXIJ4= +github.com/stackitcloud/stackit-sdk-go/services/redis v0.24.1/go.mod h1:PAQH8+1DDGc6uibvC3nDtfRLu8uxutIr25mPJvrCOy8= +github.com/stackitcloud/stackit-sdk-go/services/resourcemanager v0.16.0/go.mod h1:TBvZpbCju0Zmq8GoS4CEtUg2MqtdqWrGeEAOXwkJNQo= +github.com/stackitcloud/stackit-sdk-go/services/secretsmanager v0.12.0/go.mod h1:iD7R3CNdLUDUyKP+lATsQy+V4QGMMOb15zPnNq4wnbs= +github.com/stackitcloud/stackit-sdk-go/services/serverbackup v1.2.1/go.mod h1:S/zLsdZvtPXDSYyl7h2GLHhsnVf6AzB96PdslPWevJI= +github.com/stackitcloud/stackit-sdk-go/services/serverupdate v1.1.0/go.mod h1:5F7/2BiKhrbvHD56mj5xR9qf8P0V2yMgeitmdIpQv4s= +github.com/stackitcloud/stackit-sdk-go/services/serviceaccount v0.8.1/go.mod h1:t77MA8uyEU9KZd1On5JpnxI3xhVPKIS8WutStqvU8Cw= +github.com/stackitcloud/stackit-sdk-go/services/serviceenablement v1.2.1/go.mod h1:M4xZ2BnmROvLV2MrAP6A8o9BnyT0CkvpEcP8lBOfRs8= +github.com/stackitcloud/stackit-sdk-go/services/ske v0.27.0/go.mod h1:V09NmPahuUiuZEogVPgxuVqqti0th5B7TVAjuiM09mE= +github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex v1.2.0/go.mod h1:CyYJqR0tZWs2r5bGz69j4bmvhxdsd4QLCm1Uf+LouB0= +github.com/stackitcloud/terraform-provider-stackit v0.56.0/go.mod h1:uZ7G5NJhByxEMtrkkRB1RD/tz3mtBp4QErjFDtyKoOw= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/teambition/rrule-go v1.8.2/go.mod h1:Ieq5AbrKGciP1V//Wq8ktsTXwSwJHDD5mD/wLBGl3p4= +github.com/vmihailenco/msgpack v3.3.3+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= +github.com/vmihailenco/msgpack/v5 v5.4.1/go.mod h1:GaZTsDaehaPpQVyxrf5mtQlH+pc21PIudVV/E3rRQok= +github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zclconf/go-cty v1.16.3/go.mod h1:VvMs5i0vgZdhYawQNq5kePSpLAoz8u1xvZgrPIxfnZE= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA= +golang.org/x/oauth2 v0.29.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto/googleapis/rpc v0.0.0-20250603155806-513f23925822/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A= +google.golang.org/grpc v1.73.0/go.mod h1:50sbHOUqWoCQGI8V2HQLJM0B+LMlIUjNSZmow7EVBQc= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/provider/shim/shim.go b/provider/shim/shim.go new file mode 100644 index 0000000..6df77e8 --- /dev/null +++ b/provider/shim/shim.go @@ -0,0 +1,12 @@ +package shim + +import ( + "github.com/hashicorp/terraform-plugin-framework/provider" + "github.com/stackitcloud/pulumi-stackit/provider/pkg/version" + "github.com/stackitcloud/terraform-provider-stackit/stackit" +) + +func NewProvider() provider.Provider { + p := stackit.New(version.Version) + return p() +} diff --git a/scripts/project.sh b/scripts/project.sh new file mode 100755 index 0000000..56ab144 --- /dev/null +++ b/scripts/project.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +# This script is used to manage the project, only used for installing the required tools for now +# Usage: ./project.sh [action] +# * tools: Install required tools to run the project +set -eo pipefail + +ROOT_DIR_PROVIDER=$(git rev-parse --show-toplevel)/provider + +action=$1 + +if [ "$action" = "help" ]; then + [ -f "$0".man ] && man "$0".man || echo "No help, please read the script in ${script}, we will add help later" +elif [ "$action" = "tools" ]; then + cd ${ROOT_DIR_PROVIDER} + + go mod download + + go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.62.0 + go install github.com/hashicorp/terraform-plugin-docs/cmd/tfplugindocs@v0.21.0 +else + echo "Invalid action: '$action', please use $0 help for help" +fi \ No newline at end of file diff --git a/sdk/dotnet/AffinityGroup.cs b/sdk/dotnet/AffinityGroup.cs new file mode 100644 index 0000000..719adbb --- /dev/null +++ b/sdk/dotnet/AffinityGroup.cs @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Affinity Group schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/affinityGroup:AffinityGroup")] + public partial class AffinityGroup : global::Pulumi.CustomResource + { + /// + /// The affinity group ID. + /// + [Output("affinityGroupId")] + public Output AffinityGroupId { get; private set; } = null!; + + /// + /// The servers that are part of the affinity group. + /// + [Output("members")] + public Output> Members { get; private set; } = null!; + + /// + /// The name of the affinity group. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The policy of the affinity group. + /// + [Output("policy")] + public Output Policy { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + + /// + /// Create a AffinityGroup 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 AffinityGroup(string name, AffinityGroupArgs args, CustomResourceOptions? options = null) + : base("stackit:index/affinityGroup:AffinityGroup", name, args ?? new AffinityGroupArgs(), MakeResourceOptions(options, "")) + { + } + + private AffinityGroup(string name, Input id, AffinityGroupState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/affinityGroup:AffinityGroup", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 AffinityGroup 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 AffinityGroup Get(string name, Input id, AffinityGroupState? state = null, CustomResourceOptions? options = null) + { + return new AffinityGroup(name, id, state, options); + } + } + + public sealed class AffinityGroupArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the affinity group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The policy of the affinity group. + /// + [Input("policy", required: true)] + public Input Policy { get; set; } = null!; + + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public AffinityGroupArgs() + { + } + public static new AffinityGroupArgs Empty => new AffinityGroupArgs(); + } + + public sealed class AffinityGroupState : global::Pulumi.ResourceArgs + { + /// + /// The affinity group ID. + /// + [Input("affinityGroupId")] + public Input? AffinityGroupId { get; set; } + + [Input("members")] + private InputList? _members; + + /// + /// The servers that are part of the affinity group. + /// + public InputList Members + { + get => _members ?? (_members = new InputList()); + set => _members = value; + } + + /// + /// The name of the affinity group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The policy of the affinity group. + /// + [Input("policy")] + public Input? Policy { get; set; } + + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + public AffinityGroupState() + { + } + public static new AffinityGroupState Empty => new AffinityGroupState(); + } +} diff --git a/sdk/dotnet/AuthorizationOrganizationRoleAssignment.cs b/sdk/dotnet/AuthorizationOrganizationRoleAssignment.cs new file mode 100644 index 0000000..45b8b84 --- /dev/null +++ b/sdk/dotnet/AuthorizationOrganizationRoleAssignment.cs @@ -0,0 +1,136 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// organization Role Assignment resource schema. + /// + /// > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment")] + public partial class AuthorizationOrganizationRoleAssignment : global::Pulumi.CustomResource + { + /// + /// organization Resource to assign the role to. + /// + [Output("resourceId")] + public Output ResourceId { get; private set; } = null!; + + /// + /// Role to be assigned + /// + [Output("role")] + public Output Role { get; private set; } = null!; + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Output("subject")] + public Output Subject { get; private set; } = null!; + + + /// + /// Create a AuthorizationOrganizationRoleAssignment 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 AuthorizationOrganizationRoleAssignment(string name, AuthorizationOrganizationRoleAssignmentArgs args, CustomResourceOptions? options = null) + : base("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment", name, args ?? new AuthorizationOrganizationRoleAssignmentArgs(), MakeResourceOptions(options, "")) + { + } + + private AuthorizationOrganizationRoleAssignment(string name, Input id, AuthorizationOrganizationRoleAssignmentState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 AuthorizationOrganizationRoleAssignment 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 AuthorizationOrganizationRoleAssignment Get(string name, Input id, AuthorizationOrganizationRoleAssignmentState? state = null, CustomResourceOptions? options = null) + { + return new AuthorizationOrganizationRoleAssignment(name, id, state, options); + } + } + + public sealed class AuthorizationOrganizationRoleAssignmentArgs : global::Pulumi.ResourceArgs + { + /// + /// organization Resource to assign the role to. + /// + [Input("resourceId", required: true)] + public Input ResourceId { get; set; } = null!; + + /// + /// Role to be assigned + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Input("subject", required: true)] + public Input Subject { get; set; } = null!; + + public AuthorizationOrganizationRoleAssignmentArgs() + { + } + public static new AuthorizationOrganizationRoleAssignmentArgs Empty => new AuthorizationOrganizationRoleAssignmentArgs(); + } + + public sealed class AuthorizationOrganizationRoleAssignmentState : global::Pulumi.ResourceArgs + { + /// + /// organization Resource to assign the role to. + /// + [Input("resourceId")] + public Input? ResourceId { get; set; } + + /// + /// Role to be assigned + /// + [Input("role")] + public Input? Role { get; set; } + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Input("subject")] + public Input? Subject { get; set; } + + public AuthorizationOrganizationRoleAssignmentState() + { + } + public static new AuthorizationOrganizationRoleAssignmentState Empty => new AuthorizationOrganizationRoleAssignmentState(); + } +} diff --git a/sdk/dotnet/AuthorizationProjectRoleAssignment.cs b/sdk/dotnet/AuthorizationProjectRoleAssignment.cs new file mode 100644 index 0000000..6a01224 --- /dev/null +++ b/sdk/dotnet/AuthorizationProjectRoleAssignment.cs @@ -0,0 +1,136 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// project Role Assignment resource schema. + /// + /// > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment")] + public partial class AuthorizationProjectRoleAssignment : global::Pulumi.CustomResource + { + /// + /// project Resource to assign the role to. + /// + [Output("resourceId")] + public Output ResourceId { get; private set; } = null!; + + /// + /// Role to be assigned + /// + [Output("role")] + public Output Role { get; private set; } = null!; + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Output("subject")] + public Output Subject { get; private set; } = null!; + + + /// + /// Create a AuthorizationProjectRoleAssignment 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 AuthorizationProjectRoleAssignment(string name, AuthorizationProjectRoleAssignmentArgs args, CustomResourceOptions? options = null) + : base("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment", name, args ?? new AuthorizationProjectRoleAssignmentArgs(), MakeResourceOptions(options, "")) + { + } + + private AuthorizationProjectRoleAssignment(string name, Input id, AuthorizationProjectRoleAssignmentState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 AuthorizationProjectRoleAssignment 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 AuthorizationProjectRoleAssignment Get(string name, Input id, AuthorizationProjectRoleAssignmentState? state = null, CustomResourceOptions? options = null) + { + return new AuthorizationProjectRoleAssignment(name, id, state, options); + } + } + + public sealed class AuthorizationProjectRoleAssignmentArgs : global::Pulumi.ResourceArgs + { + /// + /// project Resource to assign the role to. + /// + [Input("resourceId", required: true)] + public Input ResourceId { get; set; } = null!; + + /// + /// Role to be assigned + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Input("subject", required: true)] + public Input Subject { get; set; } = null!; + + public AuthorizationProjectRoleAssignmentArgs() + { + } + public static new AuthorizationProjectRoleAssignmentArgs Empty => new AuthorizationProjectRoleAssignmentArgs(); + } + + public sealed class AuthorizationProjectRoleAssignmentState : global::Pulumi.ResourceArgs + { + /// + /// project Resource to assign the role to. + /// + [Input("resourceId")] + public Input? ResourceId { get; set; } + + /// + /// Role to be assigned + /// + [Input("role")] + public Input? Role { get; set; } + + /// + /// Identifier of user, service account or client. Usually email address or name in case of clients + /// + [Input("subject")] + public Input? Subject { get; set; } + + public AuthorizationProjectRoleAssignmentState() + { + } + public static new AuthorizationProjectRoleAssignmentState Empty => new AuthorizationProjectRoleAssignmentState(); + } +} diff --git a/sdk/dotnet/CdnCustomDomain.cs b/sdk/dotnet/CdnCustomDomain.cs new file mode 100644 index 0000000..4457dff --- /dev/null +++ b/sdk/dotnet/CdnCustomDomain.cs @@ -0,0 +1,157 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/cdnCustomDomain:CdnCustomDomain")] + public partial class CdnCustomDomain : global::Pulumi.CustomResource + { + /// + /// CDN distribution ID + /// + [Output("distributionId")] + public Output DistributionId { get; private set; } = null!; + + /// + /// List of distribution errors + /// + [Output("errors")] + public Output> Errors { get; private set; } = null!; + + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Status of the distribution + /// + [Output("status")] + public Output Status { get; private set; } = null!; + + + /// + /// Create a CdnCustomDomain 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 CdnCustomDomain(string name, CdnCustomDomainArgs args, CustomResourceOptions? options = null) + : base("stackit:index/cdnCustomDomain:CdnCustomDomain", name, args ?? new CdnCustomDomainArgs(), MakeResourceOptions(options, "")) + { + } + + private CdnCustomDomain(string name, Input id, CdnCustomDomainState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/cdnCustomDomain:CdnCustomDomain", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 CdnCustomDomain 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 CdnCustomDomain Get(string name, Input id, CdnCustomDomainState? state = null, CustomResourceOptions? options = null) + { + return new CdnCustomDomain(name, id, state, options); + } + } + + public sealed class CdnCustomDomainArgs : global::Pulumi.ResourceArgs + { + /// + /// CDN distribution ID + /// + [Input("distributionId", required: true)] + public Input DistributionId { get; set; } = null!; + + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public CdnCustomDomainArgs() + { + } + public static new CdnCustomDomainArgs Empty => new CdnCustomDomainArgs(); + } + + public sealed class CdnCustomDomainState : global::Pulumi.ResourceArgs + { + /// + /// CDN distribution ID + /// + [Input("distributionId")] + public Input? DistributionId { get; set; } + + [Input("errors")] + private InputList? _errors; + + /// + /// List of distribution errors + /// + public InputList Errors + { + get => _errors ?? (_errors = new InputList()); + set => _errors = value; + } + + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Status of the distribution + /// + [Input("status")] + public Input? Status { get; set; } + + public CdnCustomDomainState() + { + } + public static new CdnCustomDomainState Empty => new CdnCustomDomainState(); + } +} diff --git a/sdk/dotnet/CdnDistribution.cs b/sdk/dotnet/CdnDistribution.cs new file mode 100644 index 0000000..301f487 --- /dev/null +++ b/sdk/dotnet/CdnDistribution.cs @@ -0,0 +1,202 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/cdnDistribution:CdnDistribution")] + public partial class CdnDistribution : global::Pulumi.CustomResource + { + /// + /// The distribution configuration + /// + [Output("config")] + public Output Config { get; private set; } = null!; + + /// + /// Time when the distribution was created + /// + [Output("createdAt")] + public Output CreatedAt { get; private set; } = null!; + + /// + /// CDN distribution ID + /// + [Output("distributionId")] + public Output DistributionId { get; private set; } = null!; + + /// + /// List of configured domains for the distribution + /// + [Output("domains")] + public Output> Domains { get; private set; } = null!; + + /// + /// List of distribution errors + /// + [Output("errors")] + public Output> Errors { get; private set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Status of the distribution + /// + [Output("status")] + public Output Status { get; private set; } = null!; + + /// + /// Time when the distribution was last updated + /// + [Output("updatedAt")] + public Output UpdatedAt { get; private set; } = null!; + + + /// + /// Create a CdnDistribution 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 CdnDistribution(string name, CdnDistributionArgs args, CustomResourceOptions? options = null) + : base("stackit:index/cdnDistribution:CdnDistribution", name, args ?? new CdnDistributionArgs(), MakeResourceOptions(options, "")) + { + } + + private CdnDistribution(string name, Input id, CdnDistributionState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/cdnDistribution:CdnDistribution", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 CdnDistribution 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 CdnDistribution Get(string name, Input id, CdnDistributionState? state = null, CustomResourceOptions? options = null) + { + return new CdnDistribution(name, id, state, options); + } + } + + public sealed class CdnDistributionArgs : global::Pulumi.ResourceArgs + { + /// + /// The distribution configuration + /// + [Input("config", required: true)] + public Input Config { get; set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public CdnDistributionArgs() + { + } + public static new CdnDistributionArgs Empty => new CdnDistributionArgs(); + } + + public sealed class CdnDistributionState : global::Pulumi.ResourceArgs + { + /// + /// The distribution configuration + /// + [Input("config")] + public Input? Config { get; set; } + + /// + /// Time when the distribution was created + /// + [Input("createdAt")] + public Input? CreatedAt { get; set; } + + /// + /// CDN distribution ID + /// + [Input("distributionId")] + public Input? DistributionId { get; set; } + + [Input("domains")] + private InputList? _domains; + + /// + /// List of configured domains for the distribution + /// + public InputList Domains + { + get => _domains ?? (_domains = new InputList()); + set => _domains = value; + } + + [Input("errors")] + private InputList? _errors; + + /// + /// List of distribution errors + /// + public InputList Errors + { + get => _errors ?? (_errors = new InputList()); + set => _errors = value; + } + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Status of the distribution + /// + [Input("status")] + public Input? Status { get; set; } + + /// + /// Time when the distribution was last updated + /// + [Input("updatedAt")] + public Input? UpdatedAt { get; set; } + + public CdnDistributionState() + { + } + public static new CdnDistributionState Empty => new CdnDistributionState(); + } +} diff --git a/sdk/dotnet/Config/Config.cs b/sdk/dotnet/Config/Config.cs new file mode 100644 index 0000000..8a47f15 --- /dev/null +++ b/sdk/dotnet/Config/Config.cs @@ -0,0 +1,412 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Immutable; + +namespace Pulumi.Stackit +{ + public static class Config + { + [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "IDE1006", Justification = + "Double underscore prefix used to avoid conflicts with variable names.")] + private sealed class __Value + { + private readonly Func _getter; + private T _value = default!; + private bool _set; + + public __Value(Func getter) + { + _getter = getter; + } + + public T Get() => _set ? _value : _getter(); + + public void Set(T value) + { + _value = value; + _set = true; + } + } + + private static readonly global::Pulumi.Config __config = new global::Pulumi.Config("stackit"); + + private static readonly __Value _argusCustomEndpoint = new __Value(() => __config.Get("argusCustomEndpoint")); + /// + /// Custom endpoint for the Argus service + /// + public static string? ArgusCustomEndpoint + { + get => _argusCustomEndpoint.Get(); + set => _argusCustomEndpoint.Set(value); + } + + private static readonly __Value _authorizationCustomEndpoint = new __Value(() => __config.Get("authorizationCustomEndpoint")); + /// + /// Custom endpoint for the Membership service + /// + public static string? AuthorizationCustomEndpoint + { + get => _authorizationCustomEndpoint.Get(); + set => _authorizationCustomEndpoint.Set(value); + } + + private static readonly __Value _cdnCustomEndpoint = new __Value(() => __config.Get("cdnCustomEndpoint")); + /// + /// Custom endpoint for the CDN service + /// + public static string? CdnCustomEndpoint + { + get => _cdnCustomEndpoint.Get(); + set => _cdnCustomEndpoint.Set(value); + } + + private static readonly __Value _credentialsPath = new __Value(() => __config.Get("credentialsPath")); + /// + /// Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + /// value is `~/.stackit/credentials.json`. + /// + public static string? CredentialsPath + { + get => _credentialsPath.Get(); + set => _credentialsPath.Set(value); + } + + private static readonly __Value _defaultRegion = new __Value(() => __config.Get("defaultRegion")); + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + public static string? DefaultRegion + { + get => _defaultRegion.Get(); + set => _defaultRegion.Set(value); + } + + private static readonly __Value _dnsCustomEndpoint = new __Value(() => __config.Get("dnsCustomEndpoint")); + /// + /// Custom endpoint for the DNS service + /// + public static string? DnsCustomEndpoint + { + get => _dnsCustomEndpoint.Get(); + set => _dnsCustomEndpoint.Set(value); + } + + private static readonly __Value _enableBetaResources = new __Value(() => __config.GetBoolean("enableBetaResources")); + /// + /// Enable beta resources. Default is false. + /// + public static bool? EnableBetaResources + { + get => _enableBetaResources.Get(); + set => _enableBetaResources.Set(value); + } + + private static readonly __Value> _experiments = new __Value>(() => __config.GetObject>("experiments")); + /// + /// Enables experiments. These are unstable features without official support. More information can be found in the README. + /// Available Experiments: [iam] + /// + public static ImmutableArray Experiments + { + get => _experiments.Get(); + set => _experiments.Set(value); + } + + private static readonly __Value _gitCustomEndpoint = new __Value(() => __config.Get("gitCustomEndpoint")); + /// + /// Custom endpoint for the Git service + /// + public static string? GitCustomEndpoint + { + get => _gitCustomEndpoint.Get(); + set => _gitCustomEndpoint.Set(value); + } + + private static readonly __Value _iaasCustomEndpoint = new __Value(() => __config.Get("iaasCustomEndpoint")); + /// + /// Custom endpoint for the IaaS service + /// + public static string? IaasCustomEndpoint + { + get => _iaasCustomEndpoint.Get(); + set => _iaasCustomEndpoint.Set(value); + } + + private static readonly __Value _loadbalancerCustomEndpoint = new __Value(() => __config.Get("loadbalancerCustomEndpoint")); + /// + /// Custom endpoint for the Load Balancer service + /// + public static string? LoadbalancerCustomEndpoint + { + get => _loadbalancerCustomEndpoint.Get(); + set => _loadbalancerCustomEndpoint.Set(value); + } + + private static readonly __Value _logmeCustomEndpoint = new __Value(() => __config.Get("logmeCustomEndpoint")); + /// + /// Custom endpoint for the LogMe service + /// + public static string? LogmeCustomEndpoint + { + get => _logmeCustomEndpoint.Get(); + set => _logmeCustomEndpoint.Set(value); + } + + private static readonly __Value _mariadbCustomEndpoint = new __Value(() => __config.Get("mariadbCustomEndpoint")); + /// + /// Custom endpoint for the MariaDB service + /// + public static string? MariadbCustomEndpoint + { + get => _mariadbCustomEndpoint.Get(); + set => _mariadbCustomEndpoint.Set(value); + } + + private static readonly __Value _modelservingCustomEndpoint = new __Value(() => __config.Get("modelservingCustomEndpoint")); + /// + /// Custom endpoint for the AI Model Serving service + /// + public static string? ModelservingCustomEndpoint + { + get => _modelservingCustomEndpoint.Get(); + set => _modelservingCustomEndpoint.Set(value); + } + + private static readonly __Value _mongodbflexCustomEndpoint = new __Value(() => __config.Get("mongodbflexCustomEndpoint")); + /// + /// Custom endpoint for the MongoDB Flex service + /// + public static string? MongodbflexCustomEndpoint + { + get => _mongodbflexCustomEndpoint.Get(); + set => _mongodbflexCustomEndpoint.Set(value); + } + + private static readonly __Value _objectstorageCustomEndpoint = new __Value(() => __config.Get("objectstorageCustomEndpoint")); + /// + /// Custom endpoint for the Object Storage service + /// + public static string? ObjectstorageCustomEndpoint + { + get => _objectstorageCustomEndpoint.Get(); + set => _objectstorageCustomEndpoint.Set(value); + } + + private static readonly __Value _observabilityCustomEndpoint = new __Value(() => __config.Get("observabilityCustomEndpoint")); + /// + /// Custom endpoint for the Observability service + /// + public static string? ObservabilityCustomEndpoint + { + get => _observabilityCustomEndpoint.Get(); + set => _observabilityCustomEndpoint.Set(value); + } + + private static readonly __Value _opensearchCustomEndpoint = new __Value(() => __config.Get("opensearchCustomEndpoint")); + /// + /// Custom endpoint for the OpenSearch service + /// + public static string? OpensearchCustomEndpoint + { + get => _opensearchCustomEndpoint.Get(); + set => _opensearchCustomEndpoint.Set(value); + } + + private static readonly __Value _postgresflexCustomEndpoint = new __Value(() => __config.Get("postgresflexCustomEndpoint")); + /// + /// Custom endpoint for the PostgresFlex service + /// + public static string? PostgresflexCustomEndpoint + { + get => _postgresflexCustomEndpoint.Get(); + set => _postgresflexCustomEndpoint.Set(value); + } + + private static readonly __Value _privateKey = new __Value(() => __config.Get("privateKey")); + /// + /// Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + /// included in the service account key. + /// + public static string? PrivateKey + { + get => _privateKey.Get(); + set => _privateKey.Set(value); + } + + private static readonly __Value _privateKeyPath = new __Value(() => __config.Get("privateKeyPath")); + /// + /// Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + /// key that is included in the service account key. + /// + public static string? PrivateKeyPath + { + get => _privateKeyPath.Get(); + set => _privateKeyPath.Set(value); + } + + private static readonly __Value _rabbitmqCustomEndpoint = new __Value(() => __config.Get("rabbitmqCustomEndpoint")); + /// + /// Custom endpoint for the RabbitMQ service + /// + public static string? RabbitmqCustomEndpoint + { + get => _rabbitmqCustomEndpoint.Get(); + set => _rabbitmqCustomEndpoint.Set(value); + } + + private static readonly __Value _redisCustomEndpoint = new __Value(() => __config.Get("redisCustomEndpoint")); + /// + /// Custom endpoint for the Redis service + /// + public static string? RedisCustomEndpoint + { + get => _redisCustomEndpoint.Get(); + set => _redisCustomEndpoint.Set(value); + } + + private static readonly __Value _region = new __Value(() => __config.Get("region")); + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + public static string? Region + { + get => _region.Get(); + set => _region.Set(value); + } + + private static readonly __Value _resourcemanagerCustomEndpoint = new __Value(() => __config.Get("resourcemanagerCustomEndpoint")); + /// + /// Custom endpoint for the Resource Manager service + /// + public static string? ResourcemanagerCustomEndpoint + { + get => _resourcemanagerCustomEndpoint.Get(); + set => _resourcemanagerCustomEndpoint.Set(value); + } + + private static readonly __Value _secretsmanagerCustomEndpoint = new __Value(() => __config.Get("secretsmanagerCustomEndpoint")); + /// + /// Custom endpoint for the Secrets Manager service + /// + public static string? SecretsmanagerCustomEndpoint + { + get => _secretsmanagerCustomEndpoint.Get(); + set => _secretsmanagerCustomEndpoint.Set(value); + } + + private static readonly __Value _serverBackupCustomEndpoint = new __Value(() => __config.Get("serverBackupCustomEndpoint")); + /// + /// Custom endpoint for the Server Backup service + /// + public static string? ServerBackupCustomEndpoint + { + get => _serverBackupCustomEndpoint.Get(); + set => _serverBackupCustomEndpoint.Set(value); + } + + private static readonly __Value _serverUpdateCustomEndpoint = new __Value(() => __config.Get("serverUpdateCustomEndpoint")); + /// + /// Custom endpoint for the Server Update service + /// + public static string? ServerUpdateCustomEndpoint + { + get => _serverUpdateCustomEndpoint.Get(); + set => _serverUpdateCustomEndpoint.Set(value); + } + + private static readonly __Value _serviceAccountCustomEndpoint = new __Value(() => __config.Get("serviceAccountCustomEndpoint")); + /// + /// Custom endpoint for the Service Account service + /// + public static string? ServiceAccountCustomEndpoint + { + get => _serviceAccountCustomEndpoint.Get(); + set => _serviceAccountCustomEndpoint.Set(value); + } + + private static readonly __Value _serviceAccountEmail = new __Value(() => __config.Get("serviceAccountEmail")); + /// + /// Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + /// if you want to use the resource manager project resource. + /// + public static string? ServiceAccountEmail + { + get => _serviceAccountEmail.Get(); + set => _serviceAccountEmail.Set(value); + } + + private static readonly __Value _serviceAccountKey = new __Value(() => __config.Get("serviceAccountKey")); + /// + /// Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + /// + public static string? ServiceAccountKey + { + get => _serviceAccountKey.Get(); + set => _serviceAccountKey.Set(value); + } + + private static readonly __Value _serviceAccountKeyPath = new __Value(() => __config.Get("serviceAccountKeyPath")); + /// + /// Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + /// operations. + /// + public static string? ServiceAccountKeyPath + { + get => _serviceAccountKeyPath.Get(); + set => _serviceAccountKeyPath.Set(value); + } + + private static readonly __Value _serviceAccountToken = new __Value(() => __config.Get("serviceAccountToken")); + /// + /// Token used for authentication. If set, the token flow will be used to authenticate all operations. + /// + public static string? ServiceAccountToken + { + get => _serviceAccountToken.Get(); + set => _serviceAccountToken.Set(value); + } + + private static readonly __Value _serviceEnablementCustomEndpoint = new __Value(() => __config.Get("serviceEnablementCustomEndpoint")); + /// + /// Custom endpoint for the Service Enablement API + /// + public static string? ServiceEnablementCustomEndpoint + { + get => _serviceEnablementCustomEndpoint.Get(); + set => _serviceEnablementCustomEndpoint.Set(value); + } + + private static readonly __Value _skeCustomEndpoint = new __Value(() => __config.Get("skeCustomEndpoint")); + /// + /// Custom endpoint for the Kubernetes Engine (SKE) service + /// + public static string? SkeCustomEndpoint + { + get => _skeCustomEndpoint.Get(); + set => _skeCustomEndpoint.Set(value); + } + + private static readonly __Value _sqlserverflexCustomEndpoint = new __Value(() => __config.Get("sqlserverflexCustomEndpoint")); + /// + /// Custom endpoint for the SQL Server Flex service + /// + public static string? SqlserverflexCustomEndpoint + { + get => _sqlserverflexCustomEndpoint.Get(); + set => _sqlserverflexCustomEndpoint.Set(value); + } + + private static readonly __Value _tokenCustomEndpoint = new __Value(() => __config.Get("tokenCustomEndpoint")); + /// + /// Custom endpoint for the token API, which is used to request access tokens when using the key flow + /// + public static string? TokenCustomEndpoint + { + get => _tokenCustomEndpoint.Get(); + set => _tokenCustomEndpoint.Set(value); + } + + } +} diff --git a/sdk/dotnet/Config/README.md b/sdk/dotnet/Config/README.md new file mode 100644 index 0000000..cb19b45 --- /dev/null +++ b/sdk/dotnet/Config/README.md @@ -0,0 +1 @@ +A Pulumi package for creating and managing stackit resources. diff --git a/sdk/dotnet/DnsRecordSet.cs b/sdk/dotnet/DnsRecordSet.cs new file mode 100644 index 0000000..ab2668c --- /dev/null +++ b/sdk/dotnet/DnsRecordSet.cs @@ -0,0 +1,284 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// DNS Record Set Resource schema. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/dnsRecordSet:DnsRecordSet")] + public partial class DnsRecordSet : global::Pulumi.CustomResource + { + /// + /// Specifies if the record set is active or not. Defaults to `true` + /// + [Output("active")] + public Output Active { get; private set; } = null!; + + /// + /// Comment. + /// + [Output("comment")] + public Output Comment { get; private set; } = null!; + + /// + /// Error shows error in case create/update/delete failed. + /// + [Output("error")] + public Output Error { get; private set; } = null!; + + /// + /// Fully qualified domain name (FQDN) of the record set. + /// + [Output("fqdn")] + public Output Fqdn { get; private set; } = null!; + + /// + /// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the dns record set is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The rr set id. + /// + [Output("recordSetId")] + public Output RecordSetId { get; private set; } = null!; + + /// + /// Records. + /// + [Output("records")] + public Output> Records { get; private set; } = null!; + + /// + /// Record set state. + /// + [Output("state")] + public Output State { get; private set; } = null!; + + /// + /// Time to live. E.g. 3600 + /// + [Output("ttl")] + public Output Ttl { get; private set; } = null!; + + /// + /// The record set type. E.g. `A` or `CNAME` + /// + [Output("type")] + public Output Type { get; private set; } = null!; + + /// + /// The zone ID to which is dns record set is associated. + /// + [Output("zoneId")] + public Output ZoneId { get; private set; } = null!; + + + /// + /// Create a DnsRecordSet 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 DnsRecordSet(string name, DnsRecordSetArgs args, CustomResourceOptions? options = null) + : base("stackit:index/dnsRecordSet:DnsRecordSet", name, args ?? new DnsRecordSetArgs(), MakeResourceOptions(options, "")) + { + } + + private DnsRecordSet(string name, Input id, DnsRecordSetState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/dnsRecordSet:DnsRecordSet", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 DnsRecordSet 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 DnsRecordSet Get(string name, Input id, DnsRecordSetState? state = null, CustomResourceOptions? options = null) + { + return new DnsRecordSet(name, id, state, options); + } + } + + public sealed class DnsRecordSetArgs : global::Pulumi.ResourceArgs + { + /// + /// Specifies if the record set is active or not. Defaults to `true` + /// + [Input("active")] + public Input? Active { get; set; } + + /// + /// Comment. + /// + [Input("comment")] + public Input? Comment { get; set; } + + /// + /// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the dns record set is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("records", required: true)] + private InputList? _records; + + /// + /// Records. + /// + public InputList Records + { + get => _records ?? (_records = new InputList()); + set => _records = value; + } + + /// + /// Time to live. E.g. 3600 + /// + [Input("ttl")] + public Input? Ttl { get; set; } + + /// + /// The record set type. E.g. `A` or `CNAME` + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + /// + /// The zone ID to which is dns record set is associated. + /// + [Input("zoneId", required: true)] + public Input ZoneId { get; set; } = null!; + + public DnsRecordSetArgs() + { + } + public static new DnsRecordSetArgs Empty => new DnsRecordSetArgs(); + } + + public sealed class DnsRecordSetState : global::Pulumi.ResourceArgs + { + /// + /// Specifies if the record set is active or not. Defaults to `true` + /// + [Input("active")] + public Input? Active { get; set; } + + /// + /// Comment. + /// + [Input("comment")] + public Input? Comment { get; set; } + + /// + /// Error shows error in case create/update/delete failed. + /// + [Input("error")] + public Input? Error { get; set; } + + /// + /// Fully qualified domain name (FQDN) of the record set. + /// + [Input("fqdn")] + public Input? Fqdn { get; set; } + + /// + /// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the dns record set is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The rr set id. + /// + [Input("recordSetId")] + public Input? RecordSetId { get; set; } + + [Input("records")] + private InputList? _records; + + /// + /// Records. + /// + public InputList Records + { + get => _records ?? (_records = new InputList()); + set => _records = value; + } + + /// + /// Record set state. + /// + [Input("state")] + public Input? State { get; set; } + + /// + /// Time to live. E.g. 3600 + /// + [Input("ttl")] + public Input? Ttl { get; set; } + + /// + /// The record set type. E.g. `A` or `CNAME` + /// + [Input("type")] + public Input? Type { get; set; } + + /// + /// The zone ID to which is dns record set is associated. + /// + [Input("zoneId")] + public Input? ZoneId { get; set; } + + public DnsRecordSetState() + { + } + public static new DnsRecordSetState Empty => new DnsRecordSetState(); + } +} diff --git a/sdk/dotnet/DnsZone.cs b/sdk/dotnet/DnsZone.cs new file mode 100644 index 0000000..f9715c1 --- /dev/null +++ b/sdk/dotnet/DnsZone.cs @@ -0,0 +1,425 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// DNS Zone resource schema. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/dnsZone:DnsZone")] + public partial class DnsZone : global::Pulumi.CustomResource + { + /// + /// The access control list. E.g. `0.0.0.0/0,::/0` + /// + [Output("acl")] + public Output Acl { get; private set; } = null!; + + [Output("active")] + public Output Active { get; private set; } = null!; + + /// + /// A contact e-mail for the zone. + /// + [Output("contactEmail")] + public Output ContactEmail { get; private set; } = null!; + + /// + /// Default time to live. E.g. 3600. + /// + [Output("defaultTtl")] + public Output DefaultTtl { get; private set; } = null!; + + /// + /// Description of the zone. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// The zone name. E.g. `example.com` + /// + [Output("dnsName")] + public Output DnsName { get; private set; } = null!; + + /// + /// Expire time. E.g. 1209600. + /// + [Output("expireTime")] + public Output ExpireTime { get; private set; } = null!; + + /// + /// Specifies, if the zone is a reverse zone or not. Defaults to `false` + /// + [Output("isReverseZone")] + public Output IsReverseZone { get; private set; } = null!; + + /// + /// The user given name of the zone. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// Negative caching. E.g. 60 + /// + [Output("negativeCache")] + public Output NegativeCache { get; private set; } = null!; + + /// + /// Primary name server for secondary zone. E.g. ["1.2.3.4"] + /// + [Output("primaries")] + public Output> Primaries { get; private set; } = null!; + + /// + /// Primary name server. FQDN. + /// + [Output("primaryNameServer")] + public Output PrimaryNameServer { get; private set; } = null!; + + /// + /// STACKIT project ID to which the dns zone is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Record count how many records are in the zone. + /// + [Output("recordCount")] + public Output RecordCount { get; private set; } = null!; + + /// + /// Refresh time. E.g. 3600 + /// + [Output("refreshTime")] + public Output RefreshTime { get; private set; } = null!; + + /// + /// Retry time. E.g. 600 + /// + [Output("retryTime")] + public Output RetryTime { get; private set; } = null!; + + /// + /// Serial number. E.g. `2022111400`. + /// + [Output("serialNumber")] + public Output SerialNumber { get; private set; } = null!; + + /// + /// Zone state. E.g. `CREATE_SUCCEEDED`. + /// + [Output("state")] + public Output State { get; private set; } = null!; + + /// + /// Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + /// + [Output("type")] + public Output Type { get; private set; } = null!; + + /// + /// Visibility of the zone. E.g. `public`. + /// + [Output("visibility")] + public Output Visibility { get; private set; } = null!; + + /// + /// The zone ID. + /// + [Output("zoneId")] + public Output ZoneId { get; private set; } = null!; + + + /// + /// Create a DnsZone 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 DnsZone(string name, DnsZoneArgs args, CustomResourceOptions? options = null) + : base("stackit:index/dnsZone:DnsZone", name, args ?? new DnsZoneArgs(), MakeResourceOptions(options, "")) + { + } + + private DnsZone(string name, Input id, DnsZoneState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/dnsZone:DnsZone", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 DnsZone 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 DnsZone Get(string name, Input id, DnsZoneState? state = null, CustomResourceOptions? options = null) + { + return new DnsZone(name, id, state, options); + } + } + + public sealed class DnsZoneArgs : global::Pulumi.ResourceArgs + { + /// + /// The access control list. E.g. `0.0.0.0/0,::/0` + /// + [Input("acl")] + public Input? Acl { get; set; } + + [Input("active")] + public Input? Active { get; set; } + + /// + /// A contact e-mail for the zone. + /// + [Input("contactEmail")] + public Input? ContactEmail { get; set; } + + /// + /// Default time to live. E.g. 3600. + /// + [Input("defaultTtl")] + public Input? DefaultTtl { get; set; } + + /// + /// Description of the zone. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The zone name. E.g. `example.com` + /// + [Input("dnsName", required: true)] + public Input DnsName { get; set; } = null!; + + /// + /// Expire time. E.g. 1209600. + /// + [Input("expireTime")] + public Input? ExpireTime { get; set; } + + /// + /// Specifies, if the zone is a reverse zone or not. Defaults to `false` + /// + [Input("isReverseZone")] + public Input? IsReverseZone { get; set; } + + /// + /// The user given name of the zone. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Negative caching. E.g. 60 + /// + [Input("negativeCache")] + public Input? NegativeCache { get; set; } + + [Input("primaries")] + private InputList? _primaries; + + /// + /// Primary name server for secondary zone. E.g. ["1.2.3.4"] + /// + public InputList Primaries + { + get => _primaries ?? (_primaries = new InputList()); + set => _primaries = value; + } + + /// + /// STACKIT project ID to which the dns zone is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// Refresh time. E.g. 3600 + /// + [Input("refreshTime")] + public Input? RefreshTime { get; set; } + + /// + /// Retry time. E.g. 600 + /// + [Input("retryTime")] + public Input? RetryTime { get; set; } + + /// + /// Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + /// + [Input("type")] + public Input? Type { get; set; } + + public DnsZoneArgs() + { + } + public static new DnsZoneArgs Empty => new DnsZoneArgs(); + } + + public sealed class DnsZoneState : global::Pulumi.ResourceArgs + { + /// + /// The access control list. E.g. `0.0.0.0/0,::/0` + /// + [Input("acl")] + public Input? Acl { get; set; } + + [Input("active")] + public Input? Active { get; set; } + + /// + /// A contact e-mail for the zone. + /// + [Input("contactEmail")] + public Input? ContactEmail { get; set; } + + /// + /// Default time to live. E.g. 3600. + /// + [Input("defaultTtl")] + public Input? DefaultTtl { get; set; } + + /// + /// Description of the zone. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The zone name. E.g. `example.com` + /// + [Input("dnsName")] + public Input? DnsName { get; set; } + + /// + /// Expire time. E.g. 1209600. + /// + [Input("expireTime")] + public Input? ExpireTime { get; set; } + + /// + /// Specifies, if the zone is a reverse zone or not. Defaults to `false` + /// + [Input("isReverseZone")] + public Input? IsReverseZone { get; set; } + + /// + /// The user given name of the zone. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Negative caching. E.g. 60 + /// + [Input("negativeCache")] + public Input? NegativeCache { get; set; } + + [Input("primaries")] + private InputList? _primaries; + + /// + /// Primary name server for secondary zone. E.g. ["1.2.3.4"] + /// + public InputList Primaries + { + get => _primaries ?? (_primaries = new InputList()); + set => _primaries = value; + } + + /// + /// Primary name server. FQDN. + /// + [Input("primaryNameServer")] + public Input? PrimaryNameServer { get; set; } + + /// + /// STACKIT project ID to which the dns zone is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Record count how many records are in the zone. + /// + [Input("recordCount")] + public Input? RecordCount { get; set; } + + /// + /// Refresh time. E.g. 3600 + /// + [Input("refreshTime")] + public Input? RefreshTime { get; set; } + + /// + /// Retry time. E.g. 600 + /// + [Input("retryTime")] + public Input? RetryTime { get; set; } + + /// + /// Serial number. E.g. `2022111400`. + /// + [Input("serialNumber")] + public Input? SerialNumber { get; set; } + + /// + /// Zone state. E.g. `CREATE_SUCCEEDED`. + /// + [Input("state")] + public Input? State { get; set; } + + /// + /// Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + /// + [Input("type")] + public Input? Type { get; set; } + + /// + /// Visibility of the zone. E.g. `public`. + /// + [Input("visibility")] + public Input? Visibility { get; set; } + + /// + /// The zone ID. + /// + [Input("zoneId")] + public Input? ZoneId { get; set; } + + public DnsZoneState() + { + } + public static new DnsZoneState Empty => new DnsZoneState(); + } +} diff --git a/sdk/dotnet/GetAffinityGroup.cs b/sdk/dotnet/GetAffinityGroup.cs new file mode 100644 index 0000000..e8f44df --- /dev/null +++ b/sdk/dotnet/GetAffinityGroup.cs @@ -0,0 +1,149 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetAffinityGroup + { + /// + /// Affinity Group schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_affinity_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// affinity_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetAffinityGroupArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getAffinityGroup:getAffinityGroup", args ?? new GetAffinityGroupArgs(), options.WithDefaults()); + + /// + /// Affinity Group schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_affinity_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// affinity_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetAffinityGroupInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getAffinityGroup:getAffinityGroup", args ?? new GetAffinityGroupInvokeArgs(), options.WithDefaults()); + + /// + /// Affinity Group schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_affinity_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// affinity_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetAffinityGroupInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getAffinityGroup:getAffinityGroup", args ?? new GetAffinityGroupInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetAffinityGroupArgs : global::Pulumi.InvokeArgs + { + /// + /// The affinity group ID. + /// + [Input("affinityGroupId", required: true)] + public string AffinityGroupId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetAffinityGroupArgs() + { + } + public static new GetAffinityGroupArgs Empty => new GetAffinityGroupArgs(); + } + + public sealed class GetAffinityGroupInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The affinity group ID. + /// + [Input("affinityGroupId", required: true)] + public Input AffinityGroupId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetAffinityGroupInvokeArgs() + { + } + public static new GetAffinityGroupInvokeArgs Empty => new GetAffinityGroupInvokeArgs(); + } + + + [OutputType] + public sealed class GetAffinityGroupResult + { + /// + /// The affinity group ID. + /// + public readonly string AffinityGroupId; + public readonly string Id; + /// + /// Affinity Group schema. Must have a `region` specified in the provider configuration. + /// + public readonly ImmutableArray Members; + /// + /// The name of the affinity group. + /// + public readonly string Name; + /// + /// The policy of the affinity group. + /// + public readonly string Policy; + /// + /// STACKIT Project ID to which the affinity group is associated. + /// + public readonly string ProjectId; + + [OutputConstructor] + private GetAffinityGroupResult( + string affinityGroupId, + + string id, + + ImmutableArray members, + + string name, + + string policy, + + string projectId) + { + AffinityGroupId = affinityGroupId; + Id = id; + Members = members; + Name = name; + Policy = policy; + ProjectId = projectId; + } + } +} diff --git a/sdk/dotnet/GetCdnCustomDomain.cs b/sdk/dotnet/GetCdnCustomDomain.cs new file mode 100644 index 0000000..693b7e7 --- /dev/null +++ b/sdk/dotnet/GetCdnCustomDomain.cs @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetCdnCustomDomain + { + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_custom_domain" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "https://xxx.xxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetCdnCustomDomainArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getCdnCustomDomain:getCdnCustomDomain", args ?? new GetCdnCustomDomainArgs(), options.WithDefaults()); + + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_custom_domain" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "https://xxx.xxx" + /// } + /// ``` + /// + public static Output Invoke(GetCdnCustomDomainInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getCdnCustomDomain:getCdnCustomDomain", args ?? new GetCdnCustomDomainInvokeArgs(), options.WithDefaults()); + + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_custom_domain" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "https://xxx.xxx" + /// } + /// ``` + /// + public static Output Invoke(GetCdnCustomDomainInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getCdnCustomDomain:getCdnCustomDomain", args ?? new GetCdnCustomDomainInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetCdnCustomDomainArgs : global::Pulumi.InvokeArgs + { + /// + /// CDN distribution ID + /// + [Input("distributionId", required: true)] + public string DistributionId { get; set; } = null!; + + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetCdnCustomDomainArgs() + { + } + public static new GetCdnCustomDomainArgs Empty => new GetCdnCustomDomainArgs(); + } + + public sealed class GetCdnCustomDomainInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// CDN distribution ID + /// + [Input("distributionId", required: true)] + public Input DistributionId { get; set; } = null!; + + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetCdnCustomDomainInvokeArgs() + { + } + public static new GetCdnCustomDomainInvokeArgs Empty => new GetCdnCustomDomainInvokeArgs(); + } + + + [OutputType] + public sealed class GetCdnCustomDomainResult + { + /// + /// CDN distribution ID + /// + public readonly string DistributionId; + /// + /// List of distribution errors + /// + public readonly ImmutableArray Errors; + public readonly string Id; + public readonly string Name; + /// + /// STACKIT project ID associated with the distribution + /// + public readonly string ProjectId; + /// + /// Status of the distribution + /// + public readonly string Status; + + [OutputConstructor] + private GetCdnCustomDomainResult( + string distributionId, + + ImmutableArray errors, + + string id, + + string name, + + string projectId, + + string status) + { + DistributionId = distributionId; + Errors = errors; + Id = id; + Name = name; + ProjectId = projectId; + Status = status; + } + } +} diff --git a/sdk/dotnet/GetCdnDistribution.cs b/sdk/dotnet/GetCdnDistribution.cs new file mode 100644 index 0000000..9d6ad4b --- /dev/null +++ b/sdk/dotnet/GetCdnDistribution.cs @@ -0,0 +1,176 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetCdnDistribution + { + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_distribution" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetCdnDistributionArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getCdnDistribution:getCdnDistribution", args ?? new GetCdnDistributionArgs(), options.WithDefaults()); + + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_distribution" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetCdnDistributionInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getCdnDistribution:getCdnDistribution", args ?? new GetCdnDistributionInvokeArgs(), options.WithDefaults()); + + /// + /// CDN distribution data source schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_cdn_distribution" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// distribution_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetCdnDistributionInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getCdnDistribution:getCdnDistribution", args ?? new GetCdnDistributionInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetCdnDistributionArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID associated with the distribution + /// + [Input("distributionId", required: true)] + public string DistributionId { get; set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetCdnDistributionArgs() + { + } + public static new GetCdnDistributionArgs Empty => new GetCdnDistributionArgs(); + } + + public sealed class GetCdnDistributionInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID associated with the distribution + /// + [Input("distributionId", required: true)] + public Input DistributionId { get; set; } = null!; + + /// + /// STACKIT project ID associated with the distribution + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetCdnDistributionInvokeArgs() + { + } + public static new GetCdnDistributionInvokeArgs Empty => new GetCdnDistributionInvokeArgs(); + } + + + [OutputType] + public sealed class GetCdnDistributionResult + { + /// + /// The distribution configuration + /// + public readonly Outputs.GetCdnDistributionConfigResult Config; + /// + /// Time when the distribution was created + /// + public readonly string CreatedAt; + /// + /// STACKIT project ID associated with the distribution + /// + public readonly string DistributionId; + /// + /// List of configured domains for the distribution + /// + public readonly ImmutableArray Domains; + /// + /// List of distribution errors + /// + public readonly ImmutableArray Errors; + public readonly string Id; + /// + /// STACKIT project ID associated with the distribution + /// + public readonly string ProjectId; + /// + /// Status of the distribution + /// + public readonly string Status; + /// + /// Time when the distribution was last updated + /// + public readonly string UpdatedAt; + + [OutputConstructor] + private GetCdnDistributionResult( + Outputs.GetCdnDistributionConfigResult config, + + string createdAt, + + string distributionId, + + ImmutableArray domains, + + ImmutableArray errors, + + string id, + + string projectId, + + string status, + + string updatedAt) + { + Config = config; + CreatedAt = createdAt; + DistributionId = distributionId; + Domains = domains; + Errors = errors; + Id = id; + ProjectId = projectId; + Status = status; + UpdatedAt = updatedAt; + } + } +} diff --git a/sdk/dotnet/GetDnsRecordSet.cs b/sdk/dotnet/GetDnsRecordSet.cs new file mode 100644 index 0000000..bbbea21 --- /dev/null +++ b/sdk/dotnet/GetDnsRecordSet.cs @@ -0,0 +1,213 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetDnsRecordSet + { + /// + /// DNS Record Set Resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_record_set" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// record_set_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetDnsRecordSetArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getDnsRecordSet:getDnsRecordSet", args ?? new GetDnsRecordSetArgs(), options.WithDefaults()); + + /// + /// DNS Record Set Resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_record_set" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// record_set_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetDnsRecordSetInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getDnsRecordSet:getDnsRecordSet", args ?? new GetDnsRecordSetInvokeArgs(), options.WithDefaults()); + + /// + /// DNS Record Set Resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_record_set" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// record_set_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetDnsRecordSetInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getDnsRecordSet:getDnsRecordSet", args ?? new GetDnsRecordSetInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetDnsRecordSetArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the dns record set is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The rr set id. + /// + [Input("recordSetId", required: true)] + public string RecordSetId { get; set; } = null!; + + /// + /// The zone ID to which is dns record set is associated. + /// + [Input("zoneId", required: true)] + public string ZoneId { get; set; } = null!; + + public GetDnsRecordSetArgs() + { + } + public static new GetDnsRecordSetArgs Empty => new GetDnsRecordSetArgs(); + } + + public sealed class GetDnsRecordSetInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the dns record set is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The rr set id. + /// + [Input("recordSetId", required: true)] + public Input RecordSetId { get; set; } = null!; + + /// + /// The zone ID to which is dns record set is associated. + /// + [Input("zoneId", required: true)] + public Input ZoneId { get; set; } = null!; + + public GetDnsRecordSetInvokeArgs() + { + } + public static new GetDnsRecordSetInvokeArgs Empty => new GetDnsRecordSetInvokeArgs(); + } + + + [OutputType] + public sealed class GetDnsRecordSetResult + { + /// + /// Specifies if the record set is active or not. + /// + public readonly bool Active; + /// + /// Comment. + /// + public readonly string Comment; + /// + /// Error shows error in case create/update/delete failed. + /// + public readonly string Error; + /// + /// Fully qualified domain name (FQDN) of the record set. + /// + public readonly string Fqdn; + public readonly string Id; + /// + /// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + /// + public readonly string Name; + /// + /// STACKIT project ID to which the dns record set is associated. + /// + public readonly string ProjectId; + /// + /// The rr set id. + /// + public readonly string RecordSetId; + /// + /// Records. + /// + public readonly ImmutableArray Records; + /// + /// Record set state. + /// + public readonly string State; + /// + /// Time to live. E.g. 3600 + /// + public readonly int Ttl; + /// + /// The record set type. E.g. `A` or `CNAME` + /// + public readonly string Type; + /// + /// The zone ID to which is dns record set is associated. + /// + public readonly string ZoneId; + + [OutputConstructor] + private GetDnsRecordSetResult( + bool active, + + string comment, + + string error, + + string fqdn, + + string id, + + string name, + + string projectId, + + string recordSetId, + + ImmutableArray records, + + string state, + + int ttl, + + string type, + + string zoneId) + { + Active = active; + Comment = comment; + Error = error; + Fqdn = fqdn; + Id = id; + Name = name; + ProjectId = projectId; + RecordSetId = recordSetId; + Records = records; + State = state; + Ttl = ttl; + Type = type; + ZoneId = zoneId; + } + } +} diff --git a/sdk/dotnet/GetDnsZone.cs b/sdk/dotnet/GetDnsZone.cs new file mode 100644 index 0000000..6a823e1 --- /dev/null +++ b/sdk/dotnet/GetDnsZone.cs @@ -0,0 +1,270 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetDnsZone + { + /// + /// DNS Zone resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_zone" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetDnsZoneArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getDnsZone:getDnsZone", args ?? new GetDnsZoneArgs(), options.WithDefaults()); + + /// + /// DNS Zone resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_zone" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetDnsZoneInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getDnsZone:getDnsZone", args ?? new GetDnsZoneInvokeArgs(), options.WithDefaults()); + + /// + /// DNS Zone resource schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_dns_zone" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// zone_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetDnsZoneInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getDnsZone:getDnsZone", args ?? new GetDnsZoneInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetDnsZoneArgs : global::Pulumi.InvokeArgs + { + /// + /// The zone name. E.g. `example.com` + /// + [Input("dnsName")] + public string? DnsName { get; set; } + + /// + /// STACKIT project ID to which the dns zone is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The zone ID. + /// + [Input("zoneId")] + public string? ZoneId { get; set; } + + public GetDnsZoneArgs() + { + } + public static new GetDnsZoneArgs Empty => new GetDnsZoneArgs(); + } + + public sealed class GetDnsZoneInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The zone name. E.g. `example.com` + /// + [Input("dnsName")] + public Input? DnsName { get; set; } + + /// + /// STACKIT project ID to which the dns zone is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The zone ID. + /// + [Input("zoneId")] + public Input? ZoneId { get; set; } + + public GetDnsZoneInvokeArgs() + { + } + public static new GetDnsZoneInvokeArgs Empty => new GetDnsZoneInvokeArgs(); + } + + + [OutputType] + public sealed class GetDnsZoneResult + { + /// + /// The access control list. + /// + public readonly string Acl; + public readonly bool Active; + /// + /// A contact e-mail for the zone. + /// + public readonly string ContactEmail; + /// + /// Default time to live. + /// + public readonly int DefaultTtl; + /// + /// Description of the zone. + /// + public readonly string Description; + /// + /// The zone name. E.g. `example.com` + /// + public readonly string? DnsName; + /// + /// Expire time. + /// + public readonly int ExpireTime; + public readonly string Id; + /// + /// Specifies, if the zone is a reverse zone or not. + /// + public readonly bool IsReverseZone; + /// + /// The user given name of the zone. + /// + public readonly string Name; + /// + /// Negative caching. + /// + public readonly int NegativeCache; + /// + /// Primary name server for secondary zone. + /// + public readonly ImmutableArray Primaries; + /// + /// Primary name server. FQDN. + /// + public readonly string PrimaryNameServer; + /// + /// STACKIT project ID to which the dns zone is associated. + /// + public readonly string ProjectId; + /// + /// Record count how many records are in the zone. + /// + public readonly int RecordCount; + /// + /// Refresh time. + /// + public readonly int RefreshTime; + /// + /// Retry time. + /// + public readonly int RetryTime; + /// + /// Serial number. + /// + public readonly int SerialNumber; + /// + /// Zone state. + /// + public readonly string State; + /// + /// Zone type. + /// + public readonly string Type; + /// + /// Visibility of the zone. + /// + public readonly string Visibility; + /// + /// The zone ID. + /// + public readonly string? ZoneId; + + [OutputConstructor] + private GetDnsZoneResult( + string acl, + + bool active, + + string contactEmail, + + int defaultTtl, + + string description, + + string? dnsName, + + int expireTime, + + string id, + + bool isReverseZone, + + string name, + + int negativeCache, + + ImmutableArray primaries, + + string primaryNameServer, + + string projectId, + + int recordCount, + + int refreshTime, + + int retryTime, + + int serialNumber, + + string state, + + string type, + + string visibility, + + string? zoneId) + { + Acl = acl; + Active = active; + ContactEmail = contactEmail; + DefaultTtl = defaultTtl; + Description = description; + DnsName = dnsName; + ExpireTime = expireTime; + Id = id; + IsReverseZone = isReverseZone; + Name = name; + NegativeCache = negativeCache; + Primaries = primaries; + PrimaryNameServer = primaryNameServer; + ProjectId = projectId; + RecordCount = recordCount; + RefreshTime = refreshTime; + RetryTime = retryTime; + SerialNumber = serialNumber; + State = state; + Type = type; + Visibility = visibility; + ZoneId = zoneId; + } + } +} diff --git a/sdk/dotnet/GetGit.cs b/sdk/dotnet/GetGit.cs new file mode 100644 index 0000000..5419e9d --- /dev/null +++ b/sdk/dotnet/GetGit.cs @@ -0,0 +1,155 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetGit + { + /// + /// Git Instance datasource schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_git" "git" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetGitArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getGit:getGit", args ?? new GetGitArgs(), options.WithDefaults()); + + /// + /// Git Instance datasource schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_git" "git" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetGitInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getGit:getGit", args ?? new GetGitInvokeArgs(), options.WithDefaults()); + + /// + /// Git Instance datasource schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_git" "git" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetGitInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getGit:getGit", args ?? new GetGitInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetGitArgs : global::Pulumi.InvokeArgs + { + /// + /// ID linked to the git instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the git instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetGitArgs() + { + } + public static new GetGitArgs Empty => new GetGitArgs(); + } + + public sealed class GetGitInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID linked to the git instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the git instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetGitInvokeArgs() + { + } + public static new GetGitInvokeArgs Empty => new GetGitInvokeArgs(); + } + + + [OutputType] + public sealed class GetGitResult + { + public readonly string Id; + /// + /// ID linked to the git instance. + /// + public readonly string InstanceId; + /// + /// Unique name linked to the git instance. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the git instance is associated. + /// + public readonly string ProjectId; + /// + /// Url linked to the git instance. + /// + public readonly string Url; + /// + /// Version linked to the git instance. + /// + public readonly string Version; + + [OutputConstructor] + private GetGitResult( + string id, + + string instanceId, + + string name, + + string projectId, + + string url, + + string version) + { + Id = id; + InstanceId = instanceId; + Name = name; + ProjectId = projectId; + Url = url; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetImage.cs b/sdk/dotnet/GetImage.cs new file mode 100644 index 0000000..2516cde --- /dev/null +++ b/sdk/dotnet/GetImage.cs @@ -0,0 +1,191 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetImage + { + /// + /// Image datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_image" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// image_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetImageArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getImage:getImage", args ?? new GetImageArgs(), options.WithDefaults()); + + /// + /// Image datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_image" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// image_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetImageInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getImage:getImage", args ?? new GetImageInvokeArgs(), options.WithDefaults()); + + /// + /// Image datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_image" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// image_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetImageInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getImage:getImage", args ?? new GetImageInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetImageArgs : global::Pulumi.InvokeArgs + { + /// + /// The image ID. + /// + [Input("imageId", required: true)] + public string ImageId { get; set; } = null!; + + /// + /// STACKIT project ID to which the image is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetImageArgs() + { + } + public static new GetImageArgs Empty => new GetImageArgs(); + } + + public sealed class GetImageInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The image ID. + /// + [Input("imageId", required: true)] + public Input ImageId { get; set; } = null!; + + /// + /// STACKIT project ID to which the image is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetImageInvokeArgs() + { + } + public static new GetImageInvokeArgs Empty => new GetImageInvokeArgs(); + } + + + [OutputType] + public sealed class GetImageResult + { + /// + /// Representation of an image checksum. + /// + public readonly Outputs.GetImageChecksumResult Checksum; + /// + /// Properties to set hardware and scheduling settings for an image. + /// + public readonly Outputs.GetImageConfigResult Config; + /// + /// The disk format of the image. + /// + public readonly string DiskFormat; + public readonly string Id; + /// + /// The image ID. + /// + public readonly string ImageId; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The minimum disk size of the image in GB. + /// + public readonly int MinDiskSize; + /// + /// The minimum RAM of the image in MB. + /// + public readonly int MinRam; + /// + /// The name of the image. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the image is associated. + /// + public readonly string ProjectId; + /// + /// Whether the image is protected. + /// + public readonly bool Protected; + /// + /// The scope of the image. + /// + public readonly string Scope; + + [OutputConstructor] + private GetImageResult( + Outputs.GetImageChecksumResult checksum, + + Outputs.GetImageConfigResult config, + + string diskFormat, + + string id, + + string imageId, + + ImmutableDictionary labels, + + int minDiskSize, + + int minRam, + + string name, + + string projectId, + + bool @protected, + + string scope) + { + Checksum = checksum; + Config = config; + DiskFormat = diskFormat; + Id = id; + ImageId = imageId; + Labels = labels; + MinDiskSize = minDiskSize; + MinRam = minRam; + Name = name; + ProjectId = projectId; + Protected = @protected; + Scope = scope; + } + } +} diff --git a/sdk/dotnet/GetKeyPair.cs b/sdk/dotnet/GetKeyPair.cs new file mode 100644 index 0000000..ec1b8ad --- /dev/null +++ b/sdk/dotnet/GetKeyPair.cs @@ -0,0 +1,127 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetKeyPair + { + /// + /// Key pair resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_key_pair" "example" { + /// name = "example-key-pair-name" + /// } + /// ``` + /// + public static Task InvokeAsync(GetKeyPairArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getKeyPair:getKeyPair", args ?? new GetKeyPairArgs(), options.WithDefaults()); + + /// + /// Key pair resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_key_pair" "example" { + /// name = "example-key-pair-name" + /// } + /// ``` + /// + public static Output Invoke(GetKeyPairInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getKeyPair:getKeyPair", args ?? new GetKeyPairInvokeArgs(), options.WithDefaults()); + + /// + /// Key pair resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_key_pair" "example" { + /// name = "example-key-pair-name" + /// } + /// ``` + /// + public static Output Invoke(GetKeyPairInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getKeyPair:getKeyPair", args ?? new GetKeyPairInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetKeyPairArgs : global::Pulumi.InvokeArgs + { + /// + /// The name of the SSH key pair. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + public GetKeyPairArgs() + { + } + public static new GetKeyPairArgs Empty => new GetKeyPairArgs(); + } + + public sealed class GetKeyPairInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The name of the SSH key pair. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + public GetKeyPairInvokeArgs() + { + } + public static new GetKeyPairInvokeArgs Empty => new GetKeyPairInvokeArgs(); + } + + + [OutputType] + public sealed class GetKeyPairResult + { + /// + /// The fingerprint of the public SSH key. + /// + public readonly string Fingerprint; + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container. + /// + public readonly ImmutableDictionary Labels; + /// + /// The name of the SSH key pair. + /// + public readonly string Name; + /// + /// A string representation of the public SSH key. E.g., `ssh-rsa <key_data>` or `ssh-ed25519 <key-data>`. + /// + public readonly string PublicKey; + + [OutputConstructor] + private GetKeyPairResult( + string fingerprint, + + string id, + + ImmutableDictionary labels, + + string name, + + string publicKey) + { + Fingerprint = fingerprint; + Id = id; + Labels = labels; + Name = name; + PublicKey = publicKey; + } + } +} diff --git a/sdk/dotnet/GetLoadbalancer.cs b/sdk/dotnet/GetLoadbalancer.cs new file mode 100644 index 0000000..8aa8e10 --- /dev/null +++ b/sdk/dotnet/GetLoadbalancer.cs @@ -0,0 +1,189 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetLoadbalancer + { + /// + /// Load Balancer data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_loadbalancer" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-load-balancer" + /// } + /// ``` + /// + public static Task InvokeAsync(GetLoadbalancerArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getLoadbalancer:getLoadbalancer", args ?? new GetLoadbalancerArgs(), options.WithDefaults()); + + /// + /// Load Balancer data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_loadbalancer" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-load-balancer" + /// } + /// ``` + /// + public static Output Invoke(GetLoadbalancerInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLoadbalancer:getLoadbalancer", args ?? new GetLoadbalancerInvokeArgs(), options.WithDefaults()); + + /// + /// Load Balancer data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_loadbalancer" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-load-balancer" + /// } + /// ``` + /// + public static Output Invoke(GetLoadbalancerInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLoadbalancer:getLoadbalancer", args ?? new GetLoadbalancerInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetLoadbalancerArgs : global::Pulumi.InvokeArgs + { + /// + /// Load balancer name. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetLoadbalancerArgs() + { + } + public static new GetLoadbalancerArgs Empty => new GetLoadbalancerArgs(); + } + + public sealed class GetLoadbalancerInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Load balancer name. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetLoadbalancerInvokeArgs() + { + } + public static new GetLoadbalancerInvokeArgs Empty => new GetLoadbalancerInvokeArgs(); + } + + + [OutputType] + public sealed class GetLoadbalancerResult + { + /// + /// External Load Balancer IP address where this Load Balancer is exposed. + /// + public readonly string ExternalAddress; + public readonly string Id; + /// + /// List of all listeners which will accept traffic. Limited to 20. + /// + public readonly ImmutableArray Listeners; + /// + /// Load balancer name. + /// + public readonly string Name; + /// + /// List of networks that listeners and targets reside in. + /// + public readonly ImmutableArray Networks; + /// + /// Defines any optional functionality you want to have enabled on your load balancer. + /// + public readonly Outputs.GetLoadbalancerOptionsResult Options; + /// + /// Transient private Load Balancer IP address. It can change any time. + /// + public readonly string PrivateAddress; + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// List of all target pools which will be used in the Load Balancer. Limited to 20. + /// + public readonly ImmutableArray TargetPools; + + [OutputConstructor] + private GetLoadbalancerResult( + string externalAddress, + + string id, + + ImmutableArray listeners, + + string name, + + ImmutableArray networks, + + Outputs.GetLoadbalancerOptionsResult options, + + string privateAddress, + + string projectId, + + string? region, + + ImmutableArray targetPools) + { + ExternalAddress = externalAddress; + Id = id; + Listeners = listeners; + Name = name; + Networks = networks; + Options = options; + PrivateAddress = privateAddress; + ProjectId = projectId; + Region = region; + TargetPools = targetPools; + } + } +} diff --git a/sdk/dotnet/GetLogmeCredential.cs b/sdk/dotnet/GetLogmeCredential.cs new file mode 100644 index 0000000..8f680d3 --- /dev/null +++ b/sdk/dotnet/GetLogmeCredential.cs @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetLogmeCredential + { + /// + /// LogMe credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetLogmeCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getLogmeCredential:getLogmeCredential", args ?? new GetLogmeCredentialArgs(), options.WithDefaults()); + + /// + /// LogMe credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetLogmeCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLogmeCredential:getLogmeCredential", args ?? new GetLogmeCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// LogMe credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetLogmeCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLogmeCredential:getLogmeCredential", args ?? new GetLogmeCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetLogmeCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// ID of the LogMe instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetLogmeCredentialArgs() + { + } + public static new GetLogmeCredentialArgs Empty => new GetLogmeCredentialArgs(); + } + + public sealed class GetLogmeCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// ID of the LogMe instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetLogmeCredentialInvokeArgs() + { + } + public static new GetLogmeCredentialInvokeArgs Empty => new GetLogmeCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetLogmeCredentialResult + { + /// + /// The credential's ID. + /// + public readonly string CredentialId; + public readonly string Host; + public readonly string Id; + /// + /// ID of the LogMe instance. + /// + public readonly string InstanceId; + public readonly string Password; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly string Uri; + public readonly string Username; + + [OutputConstructor] + private GetLogmeCredentialResult( + string credentialId, + + string host, + + string id, + + string instanceId, + + string password, + + int port, + + string projectId, + + string uri, + + string username) + { + CredentialId = credentialId; + Host = host; + Id = id; + InstanceId = instanceId; + Password = password; + Port = port; + ProjectId = projectId; + Uri = uri; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetLogmeInstance.cs b/sdk/dotnet/GetLogmeInstance.cs new file mode 100644 index 0000000..f12905f --- /dev/null +++ b/sdk/dotnet/GetLogmeInstance.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetLogmeInstance + { + /// + /// LogMe instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetLogmeInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getLogmeInstance:getLogmeInstance", args ?? new GetLogmeInstanceArgs(), options.WithDefaults()); + + /// + /// LogMe instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetLogmeInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLogmeInstance:getLogmeInstance", args ?? new GetLogmeInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// LogMe instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_logme_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetLogmeInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getLogmeInstance:getLogmeInstance", args ?? new GetLogmeInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetLogmeInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the LogMe instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetLogmeInstanceArgs() + { + } + public static new GetLogmeInstanceArgs Empty => new GetLogmeInstanceArgs(); + } + + public sealed class GetLogmeInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the LogMe instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetLogmeInstanceInvokeArgs() + { + } + public static new GetLogmeInstanceInvokeArgs Empty => new GetLogmeInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetLogmeInstanceResult + { + public readonly string CfGuid; + public readonly string CfOrganizationGuid; + public readonly string CfSpaceGuid; + public readonly string DashboardUrl; + public readonly string Id; + public readonly string ImageUrl; + /// + /// ID of the LogMe instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + public readonly Outputs.GetLogmeInstanceParametersResult Parameters; + /// + /// The selected plan ID. + /// + public readonly string PlanId; + /// + /// The selected plan name. + /// + public readonly string PlanName; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The service version. + /// + public readonly string Version; + + [OutputConstructor] + private GetLogmeInstanceResult( + string cfGuid, + + string cfOrganizationGuid, + + string cfSpaceGuid, + + string dashboardUrl, + + string id, + + string imageUrl, + + string instanceId, + + string name, + + Outputs.GetLogmeInstanceParametersResult parameters, + + string planId, + + string planName, + + string projectId, + + string version) + { + CfGuid = cfGuid; + CfOrganizationGuid = cfOrganizationGuid; + CfSpaceGuid = cfSpaceGuid; + DashboardUrl = dashboardUrl; + Id = id; + ImageUrl = imageUrl; + InstanceId = instanceId; + Name = name; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetMariadbCredential.cs b/sdk/dotnet/GetMariadbCredential.cs new file mode 100644 index 0000000..0a74e6f --- /dev/null +++ b/sdk/dotnet/GetMariadbCredential.cs @@ -0,0 +1,178 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetMariadbCredential + { + /// + /// MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetMariadbCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getMariadbCredential:getMariadbCredential", args ?? new GetMariadbCredentialArgs(), options.WithDefaults()); + + /// + /// MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMariadbCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMariadbCredential:getMariadbCredential", args ?? new GetMariadbCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMariadbCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMariadbCredential:getMariadbCredential", args ?? new GetMariadbCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetMariadbCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetMariadbCredentialArgs() + { + } + public static new GetMariadbCredentialArgs Empty => new GetMariadbCredentialArgs(); + } + + public sealed class GetMariadbCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetMariadbCredentialInvokeArgs() + { + } + public static new GetMariadbCredentialInvokeArgs Empty => new GetMariadbCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetMariadbCredentialResult + { + /// + /// The credential's ID. + /// + public readonly string CredentialId; + public readonly string Host; + public readonly ImmutableArray Hosts; + public readonly string Id; + /// + /// ID of the MariaDB instance. + /// + public readonly string InstanceId; + public readonly string Name; + public readonly string Password; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly string Uri; + public readonly string Username; + + [OutputConstructor] + private GetMariadbCredentialResult( + string credentialId, + + string host, + + ImmutableArray hosts, + + string id, + + string instanceId, + + string name, + + string password, + + int port, + + string projectId, + + string uri, + + string username) + { + CredentialId = credentialId; + Host = host; + Hosts = hosts; + Id = id; + InstanceId = instanceId; + Name = name; + Password = password; + Port = port; + ProjectId = projectId; + Uri = uri; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetMariadbInstance.cs b/sdk/dotnet/GetMariadbInstance.cs new file mode 100644 index 0000000..8990aaf --- /dev/null +++ b/sdk/dotnet/GetMariadbInstance.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetMariadbInstance + { + /// + /// MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetMariadbInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getMariadbInstance:getMariadbInstance", args ?? new GetMariadbInstanceArgs(), options.WithDefaults()); + + /// + /// MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMariadbInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMariadbInstance:getMariadbInstance", args ?? new GetMariadbInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mariadb_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMariadbInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMariadbInstance:getMariadbInstance", args ?? new GetMariadbInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetMariadbInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetMariadbInstanceArgs() + { + } + public static new GetMariadbInstanceArgs Empty => new GetMariadbInstanceArgs(); + } + + public sealed class GetMariadbInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetMariadbInstanceInvokeArgs() + { + } + public static new GetMariadbInstanceInvokeArgs Empty => new GetMariadbInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetMariadbInstanceResult + { + public readonly string CfGuid; + public readonly string CfOrganizationGuid; + public readonly string CfSpaceGuid; + public readonly string DashboardUrl; + public readonly string Id; + public readonly string ImageUrl; + /// + /// ID of the MariaDB instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + public readonly Outputs.GetMariadbInstanceParametersResult Parameters; + /// + /// The selected plan ID. + /// + public readonly string PlanId; + /// + /// The selected plan name. + /// + public readonly string PlanName; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The service version. + /// + public readonly string Version; + + [OutputConstructor] + private GetMariadbInstanceResult( + string cfGuid, + + string cfOrganizationGuid, + + string cfSpaceGuid, + + string dashboardUrl, + + string id, + + string imageUrl, + + string instanceId, + + string name, + + Outputs.GetMariadbInstanceParametersResult parameters, + + string planId, + + string planName, + + string projectId, + + string version) + { + CfGuid = cfGuid; + CfOrganizationGuid = cfOrganizationGuid; + CfSpaceGuid = cfSpaceGuid; + DashboardUrl = dashboardUrl; + Id = id; + ImageUrl = imageUrl; + InstanceId = instanceId; + Name = name; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetMongodbflexInstance.cs b/sdk/dotnet/GetMongodbflexInstance.cs new file mode 100644 index 0000000..f272d91 --- /dev/null +++ b/sdk/dotnet/GetMongodbflexInstance.cs @@ -0,0 +1,172 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetMongodbflexInstance + { + /// + /// MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetMongodbflexInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getMongodbflexInstance:getMongodbflexInstance", args ?? new GetMongodbflexInstanceArgs(), options.WithDefaults()); + + /// + /// MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMongodbflexInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMongodbflexInstance:getMongodbflexInstance", args ?? new GetMongodbflexInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMongodbflexInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMongodbflexInstance:getMongodbflexInstance", args ?? new GetMongodbflexInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetMongodbflexInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetMongodbflexInstanceArgs() + { + } + public static new GetMongodbflexInstanceArgs Empty => new GetMongodbflexInstanceArgs(); + } + + public sealed class GetMongodbflexInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetMongodbflexInstanceInvokeArgs() + { + } + public static new GetMongodbflexInstanceInvokeArgs Empty => new GetMongodbflexInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetMongodbflexInstanceResult + { + /// + /// The Access Control List (ACL) for the MongoDB Flex instance. + /// + public readonly ImmutableArray Acls; + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + /// + public readonly string BackupSchedule; + public readonly Outputs.GetMongodbflexInstanceFlavorResult Flavor; + public readonly string Id; + /// + /// ID of the MongoDB Flex instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + /// + /// Custom parameters for the MongoDB Flex instance. + /// + public readonly Outputs.GetMongodbflexInstanceOptionsResult Options; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly int Replicas; + public readonly Outputs.GetMongodbflexInstanceStorageResult Storage; + public readonly string Version; + + [OutputConstructor] + private GetMongodbflexInstanceResult( + ImmutableArray acls, + + string backupSchedule, + + Outputs.GetMongodbflexInstanceFlavorResult flavor, + + string id, + + string instanceId, + + string name, + + Outputs.GetMongodbflexInstanceOptionsResult options, + + string projectId, + + int replicas, + + Outputs.GetMongodbflexInstanceStorageResult storage, + + string version) + { + Acls = acls; + BackupSchedule = backupSchedule; + Flavor = flavor; + Id = id; + InstanceId = instanceId; + Name = name; + Options = options; + ProjectId = projectId; + Replicas = replicas; + Storage = storage; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetMongodbflexUser.cs b/sdk/dotnet/GetMongodbflexUser.cs new file mode 100644 index 0000000..6c59026 --- /dev/null +++ b/sdk/dotnet/GetMongodbflexUser.cs @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetMongodbflexUser + { + /// + /// MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetMongodbflexUserArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getMongodbflexUser:getMongodbflexUser", args ?? new GetMongodbflexUserArgs(), options.WithDefaults()); + + /// + /// MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMongodbflexUserInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMongodbflexUser:getMongodbflexUser", args ?? new GetMongodbflexUserInvokeArgs(), options.WithDefaults()); + + /// + /// MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_mongodbflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetMongodbflexUserInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getMongodbflexUser:getMongodbflexUser", args ?? new GetMongodbflexUserInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetMongodbflexUserArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// User ID. + /// + [Input("userId", required: true)] + public string UserId { get; set; } = null!; + + public GetMongodbflexUserArgs() + { + } + public static new GetMongodbflexUserArgs Empty => new GetMongodbflexUserArgs(); + } + + public sealed class GetMongodbflexUserInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// User ID. + /// + [Input("userId", required: true)] + public Input UserId { get; set; } = null!; + + public GetMongodbflexUserInvokeArgs() + { + } + public static new GetMongodbflexUserInvokeArgs Empty => new GetMongodbflexUserInvokeArgs(); + } + + + [OutputType] + public sealed class GetMongodbflexUserResult + { + public readonly string Database; + public readonly string Host; + public readonly string Id; + /// + /// ID of the MongoDB Flex instance. + /// + public readonly string InstanceId; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly ImmutableArray Roles; + /// + /// User ID. + /// + public readonly string UserId; + public readonly string Username; + + [OutputConstructor] + private GetMongodbflexUserResult( + string database, + + string host, + + string id, + + string instanceId, + + int port, + + string projectId, + + ImmutableArray roles, + + string userId, + + string username) + { + Database = database; + Host = host; + Id = id; + InstanceId = instanceId; + Port = port; + ProjectId = projectId; + Roles = roles; + UserId = userId; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetNetwork.cs b/sdk/dotnet/GetNetwork.cs new file mode 100644 index 0000000..afe1c19 --- /dev/null +++ b/sdk/dotnet/GetNetwork.cs @@ -0,0 +1,240 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetNetwork + { + /// + /// Network resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetNetworkArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getNetwork:getNetwork", args ?? new GetNetworkArgs(), options.WithDefaults()); + + /// + /// Network resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetwork:getNetwork", args ?? new GetNetworkInvokeArgs(), options.WithDefaults()); + + /// + /// Network resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetwork:getNetwork", args ?? new GetNetworkInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetNetworkArgs : global::Pulumi.InvokeArgs + { + /// + /// The network ID. + /// + [Input("networkId", required: true)] + public string NetworkId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetNetworkArgs() + { + } + public static new GetNetworkArgs Empty => new GetNetworkArgs(); + } + + public sealed class GetNetworkInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The network ID. + /// + [Input("networkId", required: true)] + public Input NetworkId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetNetworkInvokeArgs() + { + } + public static new GetNetworkInvokeArgs Empty => new GetNetworkInvokeArgs(); + } + + + [OutputType] + public sealed class GetNetworkResult + { + public readonly string Id; + /// + /// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + public readonly string Ipv4Gateway; + /// + /// The IPv4 nameservers of the network. + /// + public readonly ImmutableArray Ipv4Nameservers; + /// + /// The IPv4 prefix of the network (CIDR). + /// + public readonly string Ipv4Prefix; + /// + /// The IPv4 prefix length of the network. + /// + public readonly int Ipv4PrefixLength; + /// + /// The IPv4 prefixes of the network. + /// + public readonly ImmutableArray Ipv4Prefixes; + /// + /// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + public readonly string Ipv6Gateway; + /// + /// The IPv6 nameservers of the network. + /// + public readonly ImmutableArray Ipv6Nameservers; + /// + /// The IPv6 prefix of the network (CIDR). + /// + public readonly string Ipv6Prefix; + /// + /// The IPv6 prefix length of the network. + /// + public readonly int Ipv6PrefixLength; + /// + /// The IPv6 prefixes of the network. + /// + public readonly ImmutableArray Ipv6Prefixes; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The name of the network. + /// + public readonly string Name; + /// + /// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + /// + public readonly ImmutableArray Nameservers; + /// + /// The network ID. + /// + public readonly string NetworkId; + /// + /// The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + /// + public readonly ImmutableArray Prefixes; + /// + /// STACKIT project ID to which the network is associated. + /// + public readonly string ProjectId; + /// + /// The public IP of the network. + /// + public readonly string PublicIp; + /// + /// Shows if the network is routed and therefore accessible from other networks. + /// + public readonly bool Routed; + + [OutputConstructor] + private GetNetworkResult( + string id, + + string ipv4Gateway, + + ImmutableArray ipv4Nameservers, + + string ipv4Prefix, + + int ipv4PrefixLength, + + ImmutableArray ipv4Prefixes, + + string ipv6Gateway, + + ImmutableArray ipv6Nameservers, + + string ipv6Prefix, + + int ipv6PrefixLength, + + ImmutableArray ipv6Prefixes, + + ImmutableDictionary labels, + + string name, + + ImmutableArray nameservers, + + string networkId, + + ImmutableArray prefixes, + + string projectId, + + string publicIp, + + bool routed) + { + Id = id; + Ipv4Gateway = ipv4Gateway; + Ipv4Nameservers = ipv4Nameservers; + Ipv4Prefix = ipv4Prefix; + Ipv4PrefixLength = ipv4PrefixLength; + Ipv4Prefixes = ipv4Prefixes; + Ipv6Gateway = ipv6Gateway; + Ipv6Nameservers = ipv6Nameservers; + Ipv6Prefix = ipv6Prefix; + Ipv6PrefixLength = ipv6PrefixLength; + Ipv6Prefixes = ipv6Prefixes; + Labels = labels; + Name = name; + Nameservers = nameservers; + NetworkId = networkId; + Prefixes = prefixes; + ProjectId = projectId; + PublicIp = publicIp; + Routed = routed; + } + } +} diff --git a/sdk/dotnet/GetNetworkArea.cs b/sdk/dotnet/GetNetworkArea.cs new file mode 100644 index 0000000..49d3cd6 --- /dev/null +++ b/sdk/dotnet/GetNetworkArea.cs @@ -0,0 +1,191 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetNetworkArea + { + /// + /// Network area datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetNetworkAreaArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getNetworkArea:getNetworkArea", args ?? new GetNetworkAreaArgs(), options.WithDefaults()); + + /// + /// Network area datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkAreaInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkArea:getNetworkArea", args ?? new GetNetworkAreaInvokeArgs(), options.WithDefaults()); + + /// + /// Network area datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkAreaInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkArea:getNetworkArea", args ?? new GetNetworkAreaInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetNetworkAreaArgs : global::Pulumi.InvokeArgs + { + /// + /// The network area ID. + /// + [Input("networkAreaId", required: true)] + public string NetworkAreaId { get; set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public string OrganizationId { get; set; } = null!; + + public GetNetworkAreaArgs() + { + } + public static new GetNetworkAreaArgs Empty => new GetNetworkAreaArgs(); + } + + public sealed class GetNetworkAreaInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The network area ID. + /// + [Input("networkAreaId", required: true)] + public Input NetworkAreaId { get; set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public Input OrganizationId { get; set; } = null!; + + public GetNetworkAreaInvokeArgs() + { + } + public static new GetNetworkAreaInvokeArgs Empty => new GetNetworkAreaInvokeArgs(); + } + + + [OutputType] + public sealed class GetNetworkAreaResult + { + /// + /// List of DNS Servers/Nameservers. + /// + public readonly ImmutableArray DefaultNameservers; + /// + /// The default prefix length for networks in the network area. + /// + public readonly int DefaultPrefixLength; + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The maximal prefix length for networks in the network area. + /// + public readonly int MaxPrefixLength; + /// + /// The minimal prefix length for networks in the network area. + /// + public readonly int MinPrefixLength; + /// + /// The name of the network area. + /// + public readonly string Name; + /// + /// The network area ID. + /// + public readonly string NetworkAreaId; + /// + /// List of Network ranges. + /// + public readonly ImmutableArray NetworkRanges; + /// + /// STACKIT organization ID to which the network area is associated. + /// + public readonly string OrganizationId; + /// + /// The amount of projects currently referencing this area. + /// + public readonly int ProjectCount; + /// + /// Classless Inter-Domain Routing (CIDR). + /// + public readonly string TransferNetwork; + + [OutputConstructor] + private GetNetworkAreaResult( + ImmutableArray defaultNameservers, + + int defaultPrefixLength, + + string id, + + ImmutableDictionary labels, + + int maxPrefixLength, + + int minPrefixLength, + + string name, + + string networkAreaId, + + ImmutableArray networkRanges, + + string organizationId, + + int projectCount, + + string transferNetwork) + { + DefaultNameservers = defaultNameservers; + DefaultPrefixLength = defaultPrefixLength; + Id = id; + Labels = labels; + MaxPrefixLength = maxPrefixLength; + MinPrefixLength = minPrefixLength; + Name = name; + NetworkAreaId = networkAreaId; + NetworkRanges = networkRanges; + OrganizationId = organizationId; + ProjectCount = projectCount; + TransferNetwork = transferNetwork; + } + } +} diff --git a/sdk/dotnet/GetNetworkAreaRoute.cs b/sdk/dotnet/GetNetworkAreaRoute.cs new file mode 100644 index 0000000..7ee6e85 --- /dev/null +++ b/sdk/dotnet/GetNetworkAreaRoute.cs @@ -0,0 +1,171 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetNetworkAreaRoute + { + /// + /// Network area route data resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area_route" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_route_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetNetworkAreaRouteArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", args ?? new GetNetworkAreaRouteArgs(), options.WithDefaults()); + + /// + /// Network area route data resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area_route" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_route_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkAreaRouteInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", args ?? new GetNetworkAreaRouteInvokeArgs(), options.WithDefaults()); + + /// + /// Network area route data resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_area_route" "example" { + /// organization_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_area_route_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkAreaRouteInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", args ?? new GetNetworkAreaRouteInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetNetworkAreaRouteArgs : global::Pulumi.InvokeArgs + { + /// + /// The network area ID to which the network area route is associated. + /// + [Input("networkAreaId", required: true)] + public string NetworkAreaId { get; set; } = null!; + + /// + /// The network area route ID. + /// + [Input("networkAreaRouteId", required: true)] + public string NetworkAreaRouteId { get; set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public string OrganizationId { get; set; } = null!; + + public GetNetworkAreaRouteArgs() + { + } + public static new GetNetworkAreaRouteArgs Empty => new GetNetworkAreaRouteArgs(); + } + + public sealed class GetNetworkAreaRouteInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The network area ID to which the network area route is associated. + /// + [Input("networkAreaId", required: true)] + public Input NetworkAreaId { get; set; } = null!; + + /// + /// The network area route ID. + /// + [Input("networkAreaRouteId", required: true)] + public Input NetworkAreaRouteId { get; set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public Input OrganizationId { get; set; } = null!; + + public GetNetworkAreaRouteInvokeArgs() + { + } + public static new GetNetworkAreaRouteInvokeArgs Empty => new GetNetworkAreaRouteInvokeArgs(); + } + + + [OutputType] + public sealed class GetNetworkAreaRouteResult + { + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The network area ID to which the network area route is associated. + /// + public readonly string NetworkAreaId; + /// + /// The network area route ID. + /// + public readonly string NetworkAreaRouteId; + /// + /// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + /// + public readonly string NextHop; + /// + /// STACKIT organization ID to which the network area is associated. + /// + public readonly string OrganizationId; + /// + /// The network, that is reachable though the Next Hop. Should use CIDR notation. + /// + public readonly string Prefix; + + [OutputConstructor] + private GetNetworkAreaRouteResult( + string id, + + ImmutableDictionary labels, + + string networkAreaId, + + string networkAreaRouteId, + + string nextHop, + + string organizationId, + + string prefix) + { + Id = id; + Labels = labels; + NetworkAreaId = networkAreaId; + NetworkAreaRouteId = networkAreaRouteId; + NextHop = nextHop; + OrganizationId = organizationId; + Prefix = prefix; + } + } +} diff --git a/sdk/dotnet/GetNetworkInterface.cs b/sdk/dotnet/GetNetworkInterface.cs new file mode 100644 index 0000000..fd7d501 --- /dev/null +++ b/sdk/dotnet/GetNetworkInterface.cs @@ -0,0 +1,213 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetNetworkInterface + { + /// + /// Network interface datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_interface" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_interface_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetNetworkInterfaceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getNetworkInterface:getNetworkInterface", args ?? new GetNetworkInterfaceArgs(), options.WithDefaults()); + + /// + /// Network interface datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_interface" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_interface_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkInterfaceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkInterface:getNetworkInterface", args ?? new GetNetworkInterfaceInvokeArgs(), options.WithDefaults()); + + /// + /// Network interface datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_network_interface" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// network_interface_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetNetworkInterfaceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getNetworkInterface:getNetworkInterface", args ?? new GetNetworkInterfaceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetNetworkInterfaceArgs : global::Pulumi.InvokeArgs + { + /// + /// The network ID to which the network interface is associated. + /// + [Input("networkId", required: true)] + public string NetworkId { get; set; } = null!; + + /// + /// The network interface ID. + /// + [Input("networkInterfaceId", required: true)] + public string NetworkInterfaceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network interface is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetNetworkInterfaceArgs() + { + } + public static new GetNetworkInterfaceArgs Empty => new GetNetworkInterfaceArgs(); + } + + public sealed class GetNetworkInterfaceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The network ID to which the network interface is associated. + /// + [Input("networkId", required: true)] + public Input NetworkId { get; set; } = null!; + + /// + /// The network interface ID. + /// + [Input("networkInterfaceId", required: true)] + public Input NetworkInterfaceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network interface is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetNetworkInterfaceInvokeArgs() + { + } + public static new GetNetworkInterfaceInvokeArgs Empty => new GetNetworkInterfaceInvokeArgs(); + } + + + [OutputType] + public sealed class GetNetworkInterfaceResult + { + /// + /// The list of CIDR (Classless Inter-Domain Routing) notations. + /// + public readonly ImmutableArray AllowedAddresses; + /// + /// The device UUID of the network interface. + /// + public readonly string Device; + public readonly string Id; + /// + /// The IPv4 address. + /// + public readonly string Ipv4; + /// + /// Labels are key-value string pairs which can be attached to a network interface. + /// + public readonly ImmutableDictionary Labels; + /// + /// The MAC address of network interface. + /// + public readonly string Mac; + /// + /// The name of the network interface. + /// + public readonly string Name; + /// + /// The network ID to which the network interface is associated. + /// + public readonly string NetworkId; + /// + /// The network interface ID. + /// + public readonly string NetworkInterfaceId; + /// + /// STACKIT project ID to which the network interface is associated. + /// + public readonly string ProjectId; + /// + /// The Network Interface Security. If set to false, then no security groups will apply to this network interface. + /// + public readonly bool Security; + /// + /// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + /// + public readonly ImmutableArray SecurityGroupIds; + /// + /// Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + /// + public readonly string Type; + + [OutputConstructor] + private GetNetworkInterfaceResult( + ImmutableArray allowedAddresses, + + string device, + + string id, + + string ipv4, + + ImmutableDictionary labels, + + string mac, + + string name, + + string networkId, + + string networkInterfaceId, + + string projectId, + + bool security, + + ImmutableArray securityGroupIds, + + string type) + { + AllowedAddresses = allowedAddresses; + Device = device; + Id = id; + Ipv4 = ipv4; + Labels = labels; + Mac = mac; + Name = name; + NetworkId = networkId; + NetworkInterfaceId = networkInterfaceId; + ProjectId = projectId; + Security = security; + SecurityGroupIds = securityGroupIds; + Type = type; + } + } +} diff --git a/sdk/dotnet/GetObjectstorageBucket.cs b/sdk/dotnet/GetObjectstorageBucket.cs new file mode 100644 index 0000000..c06f36f --- /dev/null +++ b/sdk/dotnet/GetObjectstorageBucket.cs @@ -0,0 +1,155 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObjectstorageBucket + { + /// + /// ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_bucket" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObjectstorageBucketArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObjectstorageBucket:getObjectstorageBucket", args ?? new GetObjectstorageBucketArgs(), options.WithDefaults()); + + /// + /// ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_bucket" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageBucketInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageBucket:getObjectstorageBucket", args ?? new GetObjectstorageBucketInvokeArgs(), options.WithDefaults()); + + /// + /// ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_bucket" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageBucketInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageBucket:getObjectstorageBucket", args ?? new GetObjectstorageBucketInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObjectstorageBucketArgs : global::Pulumi.InvokeArgs + { + /// + /// The bucket name. It must be DNS conform. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT Project ID to which the bucket is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetObjectstorageBucketArgs() + { + } + public static new GetObjectstorageBucketArgs Empty => new GetObjectstorageBucketArgs(); + } + + public sealed class GetObjectstorageBucketInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The bucket name. It must be DNS conform. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT Project ID to which the bucket is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetObjectstorageBucketInvokeArgs() + { + } + public static new GetObjectstorageBucketInvokeArgs Empty => new GetObjectstorageBucketInvokeArgs(); + } + + + [OutputType] + public sealed class GetObjectstorageBucketResult + { + public readonly string Id; + /// + /// The bucket name. It must be DNS conform. + /// + public readonly string Name; + /// + /// STACKIT Project ID to which the bucket is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + public readonly string UrlPathStyle; + public readonly string UrlVirtualHostedStyle; + + [OutputConstructor] + private GetObjectstorageBucketResult( + string id, + + string name, + + string projectId, + + string? region, + + string urlPathStyle, + + string urlVirtualHostedStyle) + { + Id = id; + Name = name; + ProjectId = projectId; + Region = region; + UrlPathStyle = urlPathStyle; + UrlVirtualHostedStyle = urlVirtualHostedStyle; + } + } +} diff --git a/sdk/dotnet/GetObjectstorageCredential.cs b/sdk/dotnet/GetObjectstorageCredential.cs new file mode 100644 index 0000000..169f2d1 --- /dev/null +++ b/sdk/dotnet/GetObjectstorageCredential.cs @@ -0,0 +1,177 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObjectstorageCredential + { + /// + /// ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObjectstorageCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObjectstorageCredential:getObjectstorageCredential", args ?? new GetObjectstorageCredentialArgs(), options.WithDefaults()); + + /// + /// ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageCredential:getObjectstorageCredential", args ?? new GetObjectstorageCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageCredential:getObjectstorageCredential", args ?? new GetObjectstorageCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObjectstorageCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// The credential group ID. + /// + [Input("credentialsGroupId", required: true)] + public string CredentialsGroupId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the credential group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetObjectstorageCredentialArgs() + { + } + public static new GetObjectstorageCredentialArgs Empty => new GetObjectstorageCredentialArgs(); + } + + public sealed class GetObjectstorageCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// The credential group ID. + /// + [Input("credentialsGroupId", required: true)] + public Input CredentialsGroupId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the credential group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetObjectstorageCredentialInvokeArgs() + { + } + public static new GetObjectstorageCredentialInvokeArgs Empty => new GetObjectstorageCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetObjectstorageCredentialResult + { + /// + /// The credential ID. + /// + public readonly string CredentialId; + /// + /// The credential group ID. + /// + public readonly string CredentialsGroupId; + public readonly string ExpirationTimestamp; + public readonly string Id; + public readonly string Name; + /// + /// STACKIT Project ID to which the credential group is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + + [OutputConstructor] + private GetObjectstorageCredentialResult( + string credentialId, + + string credentialsGroupId, + + string expirationTimestamp, + + string id, + + string name, + + string projectId, + + string? region) + { + CredentialId = credentialId; + CredentialsGroupId = credentialsGroupId; + ExpirationTimestamp = expirationTimestamp; + Id = id; + Name = name; + ProjectId = projectId; + Region = region; + } + } +} diff --git a/sdk/dotnet/GetObjectstorageCredentialsGroup.cs b/sdk/dotnet/GetObjectstorageCredentialsGroup.cs new file mode 100644 index 0000000..eefab21 --- /dev/null +++ b/sdk/dotnet/GetObjectstorageCredentialsGroup.cs @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObjectstorageCredentialsGroup + { + /// + /// ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credentials_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObjectstorageCredentialsGroupArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", args ?? new GetObjectstorageCredentialsGroupArgs(), options.WithDefaults()); + + /// + /// ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credentials_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageCredentialsGroupInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", args ?? new GetObjectstorageCredentialsGroupInvokeArgs(), options.WithDefaults()); + + /// + /// ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_objectstorage_credentials_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credentials_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObjectstorageCredentialsGroupInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", args ?? new GetObjectstorageCredentialsGroupInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObjectstorageCredentialsGroupArgs : global::Pulumi.InvokeArgs + { + /// + /// The credentials group ID. + /// + [Input("credentialsGroupId", required: true)] + public string CredentialsGroupId { get; set; } = null!; + + /// + /// Object Storage Project ID to which the credentials group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetObjectstorageCredentialsGroupArgs() + { + } + public static new GetObjectstorageCredentialsGroupArgs Empty => new GetObjectstorageCredentialsGroupArgs(); + } + + public sealed class GetObjectstorageCredentialsGroupInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credentials group ID. + /// + [Input("credentialsGroupId", required: true)] + public Input CredentialsGroupId { get; set; } = null!; + + /// + /// Object Storage Project ID to which the credentials group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetObjectstorageCredentialsGroupInvokeArgs() + { + } + public static new GetObjectstorageCredentialsGroupInvokeArgs Empty => new GetObjectstorageCredentialsGroupInvokeArgs(); + } + + + [OutputType] + public sealed class GetObjectstorageCredentialsGroupResult + { + /// + /// The credentials group ID. + /// + public readonly string CredentialsGroupId; + public readonly string Id; + /// + /// The credentials group's display name. + /// + public readonly string Name; + /// + /// Object Storage Project ID to which the credentials group is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Credentials group uniform resource name (URN) + /// + public readonly string Urn; + + [OutputConstructor] + private GetObjectstorageCredentialsGroupResult( + string credentialsGroupId, + + string id, + + string name, + + string projectId, + + string? region, + + string urn) + { + CredentialsGroupId = credentialsGroupId; + Id = id; + Name = name; + ProjectId = projectId; + Region = region; + Urn = urn; + } + } +} diff --git a/sdk/dotnet/GetObservabilityAlertgroup.cs b/sdk/dotnet/GetObservabilityAlertgroup.cs new file mode 100644 index 0000000..63f905a --- /dev/null +++ b/sdk/dotnet/GetObservabilityAlertgroup.cs @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObservabilityAlertgroup + { + /// + /// Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_alertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-alert-group" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObservabilityAlertgroupArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", args ?? new GetObservabilityAlertgroupArgs(), options.WithDefaults()); + + /// + /// Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_alertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-alert-group" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityAlertgroupInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", args ?? new GetObservabilityAlertgroupInvokeArgs(), options.WithDefaults()); + + /// + /// Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_alertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-alert-group" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityAlertgroupInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", args ?? new GetObservabilityAlertgroupInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObservabilityAlertgroupArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the alert group is associated. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the alert group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetObservabilityAlertgroupArgs() + { + } + public static new GetObservabilityAlertgroupArgs Empty => new GetObservabilityAlertgroupArgs(); + } + + public sealed class GetObservabilityAlertgroupInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the alert group is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the alert group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetObservabilityAlertgroupInvokeArgs() + { + } + public static new GetObservabilityAlertgroupInvokeArgs Empty => new GetObservabilityAlertgroupInvokeArgs(); + } + + + [OutputType] + public sealed class GetObservabilityAlertgroupResult + { + public readonly string Id; + /// + /// Observability instance ID to which the alert group is associated. + /// + public readonly string InstanceId; + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + public readonly string Interval; + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the alert group is associated. + /// + public readonly string ProjectId; + public readonly ImmutableArray Rules; + + [OutputConstructor] + private GetObservabilityAlertgroupResult( + string id, + + string instanceId, + + string interval, + + string name, + + string projectId, + + ImmutableArray rules) + { + Id = id; + InstanceId = instanceId; + Interval = interval; + Name = name; + ProjectId = projectId; + Rules = rules; + } + } +} diff --git a/sdk/dotnet/GetObservabilityInstance.cs b/sdk/dotnet/GetObservabilityInstance.cs new file mode 100644 index 0000000..72d29d9 --- /dev/null +++ b/sdk/dotnet/GetObservabilityInstance.cs @@ -0,0 +1,291 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObservabilityInstance + { + /// + /// Observability instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObservabilityInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObservabilityInstance:getObservabilityInstance", args ?? new GetObservabilityInstanceArgs(), options.WithDefaults()); + + /// + /// Observability instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityInstance:getObservabilityInstance", args ?? new GetObservabilityInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// Observability instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityInstance:getObservabilityInstance", args ?? new GetObservabilityInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObservabilityInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// The Observability instance ID. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetObservabilityInstanceArgs() + { + } + public static new GetObservabilityInstanceArgs Empty => new GetObservabilityInstanceArgs(); + } + + public sealed class GetObservabilityInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The Observability instance ID. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetObservabilityInstanceInvokeArgs() + { + } + public static new GetObservabilityInstanceInvokeArgs Empty => new GetObservabilityInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetObservabilityInstanceResult + { + /// + /// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + /// + public readonly ImmutableArray Acls; + /// + /// Alert configuration for the instance. + /// + public readonly Outputs.GetObservabilityInstanceAlertConfigResult AlertConfig; + /// + /// Specifies Alerting URL. + /// + public readonly string AlertingUrl; + /// + /// Specifies Observability instance dashboard URL. + /// + public readonly string DashboardUrl; + /// + /// Specifies an initial Grafana admin password. + /// + public readonly string GrafanaInitialAdminPassword; + /// + /// Specifies an initial Grafana admin username. + /// + public readonly string GrafanaInitialAdminUser; + /// + /// If true, anyone can access Grafana dashboards without logging in. + /// + public readonly bool GrafanaPublicReadAccess; + /// + /// Specifies Grafana URL. + /// + public readonly string GrafanaUrl; + public readonly string Id; + /// + /// The Observability instance ID. + /// + public readonly string InstanceId; + /// + /// Specifies if the instance can be updated. + /// + public readonly bool IsUpdatable; + public readonly string JaegerTracesUrl; + public readonly string JaegerUiUrl; + /// + /// Specifies URL for pushing logs. + /// + public readonly string LogsPushUrl; + /// + /// Specifies Logs URL. + /// + public readonly string LogsUrl; + /// + /// Specifies URL for pushing metrics. + /// + public readonly string MetricsPushUrl; + /// + /// Specifies for how many days the raw metrics are kept. + /// + public readonly int MetricsRetentionDays; + /// + /// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + /// + public readonly int MetricsRetentionDays1hDownsampling; + /// + /// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + /// + public readonly int MetricsRetentionDays5mDownsampling; + /// + /// Specifies metrics URL. + /// + public readonly string MetricsUrl; + /// + /// The name of the Observability instance. + /// + public readonly string Name; + public readonly string OtlpTracesUrl; + /// + /// Additional parameters. + /// + public readonly ImmutableDictionary Parameters; + /// + /// The Observability plan ID. + /// + public readonly string PlanId; + /// + /// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + /// + public readonly string PlanName; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// Specifies Targets URL. + /// + public readonly string TargetsUrl; + public readonly string ZipkinSpansUrl; + + [OutputConstructor] + private GetObservabilityInstanceResult( + ImmutableArray acls, + + Outputs.GetObservabilityInstanceAlertConfigResult alertConfig, + + string alertingUrl, + + string dashboardUrl, + + string grafanaInitialAdminPassword, + + string grafanaInitialAdminUser, + + bool grafanaPublicReadAccess, + + string grafanaUrl, + + string id, + + string instanceId, + + bool isUpdatable, + + string jaegerTracesUrl, + + string jaegerUiUrl, + + string logsPushUrl, + + string logsUrl, + + string metricsPushUrl, + + int metricsRetentionDays, + + int metricsRetentionDays1hDownsampling, + + int metricsRetentionDays5mDownsampling, + + string metricsUrl, + + string name, + + string otlpTracesUrl, + + ImmutableDictionary parameters, + + string planId, + + string planName, + + string projectId, + + string targetsUrl, + + string zipkinSpansUrl) + { + Acls = acls; + AlertConfig = alertConfig; + AlertingUrl = alertingUrl; + DashboardUrl = dashboardUrl; + GrafanaInitialAdminPassword = grafanaInitialAdminPassword; + GrafanaInitialAdminUser = grafanaInitialAdminUser; + GrafanaPublicReadAccess = grafanaPublicReadAccess; + GrafanaUrl = grafanaUrl; + Id = id; + InstanceId = instanceId; + IsUpdatable = isUpdatable; + JaegerTracesUrl = jaegerTracesUrl; + JaegerUiUrl = jaegerUiUrl; + LogsPushUrl = logsPushUrl; + LogsUrl = logsUrl; + MetricsPushUrl = metricsPushUrl; + MetricsRetentionDays = metricsRetentionDays; + MetricsRetentionDays1hDownsampling = metricsRetentionDays1hDownsampling; + MetricsRetentionDays5mDownsampling = metricsRetentionDays5mDownsampling; + MetricsUrl = metricsUrl; + Name = name; + OtlpTracesUrl = otlpTracesUrl; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + TargetsUrl = targetsUrl; + ZipkinSpansUrl = zipkinSpansUrl; + } + } +} diff --git a/sdk/dotnet/GetObservabilityLogalertgroup.cs b/sdk/dotnet/GetObservabilityLogalertgroup.cs new file mode 100644 index 0000000..2a03b9e --- /dev/null +++ b/sdk/dotnet/GetObservabilityLogalertgroup.cs @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObservabilityLogalertgroup + { + /// + /// Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_logalertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-log-alert-group" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObservabilityLogalertgroupArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", args ?? new GetObservabilityLogalertgroupArgs(), options.WithDefaults()); + + /// + /// Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_logalertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-log-alert-group" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityLogalertgroupInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", args ?? new GetObservabilityLogalertgroupInvokeArgs(), options.WithDefaults()); + + /// + /// Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_logalertgroup" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-log-alert-group" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityLogalertgroupInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", args ?? new GetObservabilityLogalertgroupInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObservabilityLogalertgroupArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the log alert group is associated. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the log alert group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetObservabilityLogalertgroupArgs() + { + } + public static new GetObservabilityLogalertgroupArgs Empty => new GetObservabilityLogalertgroupArgs(); + } + + public sealed class GetObservabilityLogalertgroupInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the log alert group is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the log alert group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetObservabilityLogalertgroupInvokeArgs() + { + } + public static new GetObservabilityLogalertgroupInvokeArgs Empty => new GetObservabilityLogalertgroupInvokeArgs(); + } + + + [OutputType] + public sealed class GetObservabilityLogalertgroupResult + { + public readonly string Id; + /// + /// Observability instance ID to which the log alert group is associated. + /// + public readonly string InstanceId; + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + public readonly string Interval; + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the log alert group is associated. + /// + public readonly string ProjectId; + public readonly ImmutableArray Rules; + + [OutputConstructor] + private GetObservabilityLogalertgroupResult( + string id, + + string instanceId, + + string interval, + + string name, + + string projectId, + + ImmutableArray rules) + { + Id = id; + InstanceId = instanceId; + Interval = interval; + Name = name; + ProjectId = projectId; + Rules = rules; + } + } +} diff --git a/sdk/dotnet/GetObservabilityScrapeconfig.cs b/sdk/dotnet/GetObservabilityScrapeconfig.cs new file mode 100644 index 0000000..2ee3fb2 --- /dev/null +++ b/sdk/dotnet/GetObservabilityScrapeconfig.cs @@ -0,0 +1,206 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetObservabilityScrapeconfig + { + /// + /// Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_scrapeconfig" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example" + /// } + /// ``` + /// + public static Task InvokeAsync(GetObservabilityScrapeconfigArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", args ?? new GetObservabilityScrapeconfigArgs(), options.WithDefaults()); + + /// + /// Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_scrapeconfig" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityScrapeconfigInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", args ?? new GetObservabilityScrapeconfigInvokeArgs(), options.WithDefaults()); + + /// + /// Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_observability_scrapeconfig" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example" + /// } + /// ``` + /// + public static Output Invoke(GetObservabilityScrapeconfigInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", args ?? new GetObservabilityScrapeconfigInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetObservabilityScrapeconfigArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the scraping job is associated. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// Specifies the name of the scraping job + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the scraping job is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetObservabilityScrapeconfigArgs() + { + } + public static new GetObservabilityScrapeconfigArgs Empty => new GetObservabilityScrapeconfigArgs(); + } + + public sealed class GetObservabilityScrapeconfigInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Observability instance ID to which the scraping job is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// Specifies the name of the scraping job + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the scraping job is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetObservabilityScrapeconfigInvokeArgs() + { + } + public static new GetObservabilityScrapeconfigInvokeArgs Empty => new GetObservabilityScrapeconfigInvokeArgs(); + } + + + [OutputType] + public sealed class GetObservabilityScrapeconfigResult + { + /// + /// A basic authentication block. + /// + public readonly Outputs.GetObservabilityScrapeconfigBasicAuthResult BasicAuth; + public readonly string Id; + /// + /// Observability instance ID to which the scraping job is associated. + /// + public readonly string InstanceId; + /// + /// Specifies the job scraping url path. + /// + public readonly string MetricsPath; + /// + /// Specifies the name of the scraping job + /// + public readonly string Name; + /// + /// STACKIT project ID to which the scraping job is associated. + /// + public readonly string ProjectId; + /// + /// A SAML2 configuration block. + /// + public readonly Outputs.GetObservabilityScrapeconfigSaml2Result Saml2; + /// + /// Specifies the scrape sample limit. + /// + public readonly int SampleLimit; + /// + /// Specifies the http scheme. + /// + public readonly string Scheme; + /// + /// Specifies the scrape interval as duration string. + /// + public readonly string ScrapeInterval; + /// + /// Specifies the scrape timeout as duration string. + /// + public readonly string ScrapeTimeout; + /// + /// The targets list (specified by the static config). + /// + public readonly ImmutableArray Targets; + + [OutputConstructor] + private GetObservabilityScrapeconfigResult( + Outputs.GetObservabilityScrapeconfigBasicAuthResult basicAuth, + + string id, + + string instanceId, + + string metricsPath, + + string name, + + string projectId, + + Outputs.GetObservabilityScrapeconfigSaml2Result saml2, + + int sampleLimit, + + string scheme, + + string scrapeInterval, + + string scrapeTimeout, + + ImmutableArray targets) + { + BasicAuth = basicAuth; + Id = id; + InstanceId = instanceId; + MetricsPath = metricsPath; + Name = name; + ProjectId = projectId; + Saml2 = saml2; + SampleLimit = sampleLimit; + Scheme = scheme; + ScrapeInterval = scrapeInterval; + ScrapeTimeout = scrapeTimeout; + Targets = targets; + } + } +} diff --git a/sdk/dotnet/GetOpensearchCredential.cs b/sdk/dotnet/GetOpensearchCredential.cs new file mode 100644 index 0000000..3ea0e19 --- /dev/null +++ b/sdk/dotnet/GetOpensearchCredential.cs @@ -0,0 +1,178 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetOpensearchCredential + { + /// + /// OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetOpensearchCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getOpensearchCredential:getOpensearchCredential", args ?? new GetOpensearchCredentialArgs(), options.WithDefaults()); + + /// + /// OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetOpensearchCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getOpensearchCredential:getOpensearchCredential", args ?? new GetOpensearchCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetOpensearchCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getOpensearchCredential:getOpensearchCredential", args ?? new GetOpensearchCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetOpensearchCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetOpensearchCredentialArgs() + { + } + public static new GetOpensearchCredentialArgs Empty => new GetOpensearchCredentialArgs(); + } + + public sealed class GetOpensearchCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetOpensearchCredentialInvokeArgs() + { + } + public static new GetOpensearchCredentialInvokeArgs Empty => new GetOpensearchCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetOpensearchCredentialResult + { + /// + /// The credential's ID. + /// + public readonly string CredentialId; + public readonly string Host; + public readonly ImmutableArray Hosts; + public readonly string Id; + /// + /// ID of the OpenSearch instance. + /// + public readonly string InstanceId; + public readonly string Password; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly string Scheme; + public readonly string Uri; + public readonly string Username; + + [OutputConstructor] + private GetOpensearchCredentialResult( + string credentialId, + + string host, + + ImmutableArray hosts, + + string id, + + string instanceId, + + string password, + + int port, + + string projectId, + + string scheme, + + string uri, + + string username) + { + CredentialId = credentialId; + Host = host; + Hosts = hosts; + Id = id; + InstanceId = instanceId; + Password = password; + Port = port; + ProjectId = projectId; + Scheme = scheme; + Uri = uri; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetOpensearchInstance.cs b/sdk/dotnet/GetOpensearchInstance.cs new file mode 100644 index 0000000..aa16654 --- /dev/null +++ b/sdk/dotnet/GetOpensearchInstance.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetOpensearchInstance + { + /// + /// OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetOpensearchInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getOpensearchInstance:getOpensearchInstance", args ?? new GetOpensearchInstanceArgs(), options.WithDefaults()); + + /// + /// OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetOpensearchInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getOpensearchInstance:getOpensearchInstance", args ?? new GetOpensearchInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_opensearch_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetOpensearchInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getOpensearchInstance:getOpensearchInstance", args ?? new GetOpensearchInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetOpensearchInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetOpensearchInstanceArgs() + { + } + public static new GetOpensearchInstanceArgs Empty => new GetOpensearchInstanceArgs(); + } + + public sealed class GetOpensearchInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetOpensearchInstanceInvokeArgs() + { + } + public static new GetOpensearchInstanceInvokeArgs Empty => new GetOpensearchInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetOpensearchInstanceResult + { + public readonly string CfGuid; + public readonly string CfOrganizationGuid; + public readonly string CfSpaceGuid; + public readonly string DashboardUrl; + public readonly string Id; + public readonly string ImageUrl; + /// + /// ID of the OpenSearch instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + public readonly Outputs.GetOpensearchInstanceParametersResult Parameters; + /// + /// The selected plan ID. + /// + public readonly string PlanId; + /// + /// The selected plan name. + /// + public readonly string PlanName; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The service version. + /// + public readonly string Version; + + [OutputConstructor] + private GetOpensearchInstanceResult( + string cfGuid, + + string cfOrganizationGuid, + + string cfSpaceGuid, + + string dashboardUrl, + + string id, + + string imageUrl, + + string instanceId, + + string name, + + Outputs.GetOpensearchInstanceParametersResult parameters, + + string planId, + + string planName, + + string projectId, + + string version) + { + CfGuid = cfGuid; + CfOrganizationGuid = cfOrganizationGuid; + CfSpaceGuid = cfSpaceGuid; + DashboardUrl = dashboardUrl; + Id = id; + ImageUrl = imageUrl; + InstanceId = instanceId; + Name = name; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetPostgresflexDatabase.cs b/sdk/dotnet/GetPostgresflexDatabase.cs new file mode 100644 index 0000000..c8945e8 --- /dev/null +++ b/sdk/dotnet/GetPostgresflexDatabase.cs @@ -0,0 +1,183 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetPostgresflexDatabase + { + /// + /// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_database" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// database_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetPostgresflexDatabaseArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", args ?? new GetPostgresflexDatabaseArgs(), options.WithDefaults()); + + /// + /// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_database" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// database_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexDatabaseInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", args ?? new GetPostgresflexDatabaseInvokeArgs(), options.WithDefaults()); + + /// + /// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_database" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// database_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexDatabaseInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", args ?? new GetPostgresflexDatabaseInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetPostgresflexDatabaseArgs : global::Pulumi.InvokeArgs + { + /// + /// Database ID. + /// + [Input("databaseId", required: true)] + public string DatabaseId { get; set; } = null!; + + /// + /// ID of the Postgres Flex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetPostgresflexDatabaseArgs() + { + } + public static new GetPostgresflexDatabaseArgs Empty => new GetPostgresflexDatabaseArgs(); + } + + public sealed class GetPostgresflexDatabaseInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Database ID. + /// + [Input("databaseId", required: true)] + public Input DatabaseId { get; set; } = null!; + + /// + /// ID of the Postgres Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetPostgresflexDatabaseInvokeArgs() + { + } + public static new GetPostgresflexDatabaseInvokeArgs Empty => new GetPostgresflexDatabaseInvokeArgs(); + } + + + [OutputType] + public sealed class GetPostgresflexDatabaseResult + { + /// + /// Database ID. + /// + public readonly string DatabaseId; + public readonly string Id; + /// + /// ID of the Postgres Flex instance. + /// + public readonly string InstanceId; + /// + /// Database name. + /// + public readonly string Name; + /// + /// Username of the database owner. + /// + public readonly string Owner; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + + [OutputConstructor] + private GetPostgresflexDatabaseResult( + string databaseId, + + string id, + + string instanceId, + + string name, + + string owner, + + string projectId, + + string? region) + { + DatabaseId = databaseId; + Id = id; + InstanceId = instanceId; + Name = name; + Owner = owner; + ProjectId = projectId; + Region = region; + } + } +} diff --git a/sdk/dotnet/GetPostgresflexInstance.cs b/sdk/dotnet/GetPostgresflexInstance.cs new file mode 100644 index 0000000..b2a68c6 --- /dev/null +++ b/sdk/dotnet/GetPostgresflexInstance.cs @@ -0,0 +1,181 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetPostgresflexInstance + { + /// + /// Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetPostgresflexInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getPostgresflexInstance:getPostgresflexInstance", args ?? new GetPostgresflexInstanceArgs(), options.WithDefaults()); + + /// + /// Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexInstance:getPostgresflexInstance", args ?? new GetPostgresflexInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexInstance:getPostgresflexInstance", args ?? new GetPostgresflexInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetPostgresflexInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetPostgresflexInstanceArgs() + { + } + public static new GetPostgresflexInstanceArgs Empty => new GetPostgresflexInstanceArgs(); + } + + public sealed class GetPostgresflexInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetPostgresflexInstanceInvokeArgs() + { + } + public static new GetPostgresflexInstanceInvokeArgs Empty => new GetPostgresflexInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetPostgresflexInstanceResult + { + /// + /// The Access Control List (ACL) for the PostgresFlex instance. + /// + public readonly ImmutableArray Acls; + public readonly string BackupSchedule; + public readonly Outputs.GetPostgresflexInstanceFlavorResult Flavor; + public readonly string Id; + /// + /// ID of the PostgresFlex instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + public readonly int Replicas; + public readonly Outputs.GetPostgresflexInstanceStorageResult Storage; + public readonly string Version; + + [OutputConstructor] + private GetPostgresflexInstanceResult( + ImmutableArray acls, + + string backupSchedule, + + Outputs.GetPostgresflexInstanceFlavorResult flavor, + + string id, + + string instanceId, + + string name, + + string projectId, + + string? region, + + int replicas, + + Outputs.GetPostgresflexInstanceStorageResult storage, + + string version) + { + Acls = acls; + BackupSchedule = backupSchedule; + Flavor = flavor; + Id = id; + InstanceId = instanceId; + Name = name; + ProjectId = projectId; + Region = region; + Replicas = replicas; + Storage = storage; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetPostgresflexUser.cs b/sdk/dotnet/GetPostgresflexUser.cs new file mode 100644 index 0000000..77f0100 --- /dev/null +++ b/sdk/dotnet/GetPostgresflexUser.cs @@ -0,0 +1,185 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetPostgresflexUser + { + /// + /// Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetPostgresflexUserArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getPostgresflexUser:getPostgresflexUser", args ?? new GetPostgresflexUserArgs(), options.WithDefaults()); + + /// + /// Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexUserInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexUser:getPostgresflexUser", args ?? new GetPostgresflexUserInvokeArgs(), options.WithDefaults()); + + /// + /// Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_postgresflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPostgresflexUserInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPostgresflexUser:getPostgresflexUser", args ?? new GetPostgresflexUserInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetPostgresflexUserArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// User ID. + /// + [Input("userId", required: true)] + public string UserId { get; set; } = null!; + + public GetPostgresflexUserArgs() + { + } + public static new GetPostgresflexUserArgs Empty => new GetPostgresflexUserArgs(); + } + + public sealed class GetPostgresflexUserInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// User ID. + /// + [Input("userId", required: true)] + public Input UserId { get; set; } = null!; + + public GetPostgresflexUserInvokeArgs() + { + } + public static new GetPostgresflexUserInvokeArgs Empty => new GetPostgresflexUserInvokeArgs(); + } + + + [OutputType] + public sealed class GetPostgresflexUserResult + { + public readonly string Host; + public readonly string Id; + /// + /// ID of the PostgresFlex instance. + /// + public readonly string InstanceId; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + public readonly ImmutableArray Roles; + /// + /// User ID. + /// + public readonly string UserId; + public readonly string Username; + + [OutputConstructor] + private GetPostgresflexUserResult( + string host, + + string id, + + string instanceId, + + int port, + + string projectId, + + string? region, + + ImmutableArray roles, + + string userId, + + string username) + { + Host = host; + Id = id; + InstanceId = instanceId; + Port = port; + ProjectId = projectId; + Region = region; + Roles = roles; + UserId = userId; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetPublicIp.cs b/sdk/dotnet/GetPublicIp.cs new file mode 100644 index 0000000..dc19338 --- /dev/null +++ b/sdk/dotnet/GetPublicIp.cs @@ -0,0 +1,149 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetPublicIp + { + /// + /// Public IP resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// public_ip_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetPublicIpArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getPublicIp:getPublicIp", args ?? new GetPublicIpArgs(), options.WithDefaults()); + + /// + /// Public IP resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// public_ip_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPublicIpInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPublicIp:getPublicIp", args ?? new GetPublicIpInvokeArgs(), options.WithDefaults()); + + /// + /// Public IP resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// public_ip_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetPublicIpInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPublicIp:getPublicIp", args ?? new GetPublicIpInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetPublicIpArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The public IP ID. + /// + [Input("publicIpId", required: true)] + public string PublicIpId { get; set; } = null!; + + public GetPublicIpArgs() + { + } + public static new GetPublicIpArgs Empty => new GetPublicIpArgs(); + } + + public sealed class GetPublicIpInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The public IP ID. + /// + [Input("publicIpId", required: true)] + public Input PublicIpId { get; set; } = null!; + + public GetPublicIpInvokeArgs() + { + } + public static new GetPublicIpInvokeArgs Empty => new GetPublicIpInvokeArgs(); + } + + + [OutputType] + public sealed class GetPublicIpResult + { + public readonly string Id; + /// + /// The IP address. + /// + public readonly string Ip; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// Associates the public IP with a network interface or a virtual IP (ID). + /// + public readonly string NetworkInterfaceId; + /// + /// STACKIT project ID to which the public IP is associated. + /// + public readonly string ProjectId; + /// + /// The public IP ID. + /// + public readonly string PublicIpId; + + [OutputConstructor] + private GetPublicIpResult( + string id, + + string ip, + + ImmutableDictionary labels, + + string networkInterfaceId, + + string projectId, + + string publicIpId) + { + Id = id; + Ip = ip; + Labels = labels; + NetworkInterfaceId = networkInterfaceId; + ProjectId = projectId; + PublicIpId = publicIpId; + } + } +} diff --git a/sdk/dotnet/GetPublicIpRanges.cs b/sdk/dotnet/GetPublicIpRanges.cs new file mode 100644 index 0000000..89b308c --- /dev/null +++ b/sdk/dotnet/GetPublicIpRanges.cs @@ -0,0 +1,71 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetPublicIpRanges + { + /// + /// A list of all public IP ranges that STACKIT uses. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip_ranges" "example" {} + /// ``` + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getPublicIpRanges:getPublicIpRanges", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// A list of all public IP ranges that STACKIT uses. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip_ranges" "example" {} + /// ``` + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPublicIpRanges:getPublicIpRanges", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// A list of all public IP ranges that STACKIT uses. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_public_ip_ranges" "example" {} + /// ``` + /// + public static Output Invoke(InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getPublicIpRanges:getPublicIpRanges", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetPublicIpRangesResult + { + public readonly string Id; + /// + /// A list of all public IP ranges. + /// + public readonly ImmutableArray PublicIpRanges; + + [OutputConstructor] + private GetPublicIpRangesResult( + string id, + + ImmutableArray publicIpRanges) + { + Id = id; + PublicIpRanges = publicIpRanges; + } + } +} diff --git a/sdk/dotnet/GetRabbitmqCredential.cs b/sdk/dotnet/GetRabbitmqCredential.cs new file mode 100644 index 0000000..87ca821 --- /dev/null +++ b/sdk/dotnet/GetRabbitmqCredential.cs @@ -0,0 +1,190 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetRabbitmqCredential + { + /// + /// RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetRabbitmqCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getRabbitmqCredential:getRabbitmqCredential", args ?? new GetRabbitmqCredentialArgs(), options.WithDefaults()); + + /// + /// RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRabbitmqCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRabbitmqCredential:getRabbitmqCredential", args ?? new GetRabbitmqCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRabbitmqCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRabbitmqCredential:getRabbitmqCredential", args ?? new GetRabbitmqCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetRabbitmqCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetRabbitmqCredentialArgs() + { + } + public static new GetRabbitmqCredentialArgs Empty => new GetRabbitmqCredentialArgs(); + } + + public sealed class GetRabbitmqCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetRabbitmqCredentialInvokeArgs() + { + } + public static new GetRabbitmqCredentialInvokeArgs Empty => new GetRabbitmqCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetRabbitmqCredentialResult + { + /// + /// The credential's ID. + /// + public readonly string CredentialId; + public readonly string Host; + public readonly ImmutableArray Hosts; + public readonly string HttpApiUri; + public readonly ImmutableArray HttpApiUris; + public readonly string Id; + /// + /// ID of the RabbitMQ instance. + /// + public readonly string InstanceId; + public readonly string Management; + public readonly string Password; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + public readonly string Uri; + public readonly ImmutableArray Uris; + public readonly string Username; + + [OutputConstructor] + private GetRabbitmqCredentialResult( + string credentialId, + + string host, + + ImmutableArray hosts, + + string httpApiUri, + + ImmutableArray httpApiUris, + + string id, + + string instanceId, + + string management, + + string password, + + int port, + + string projectId, + + string uri, + + ImmutableArray uris, + + string username) + { + CredentialId = credentialId; + Host = host; + Hosts = hosts; + HttpApiUri = httpApiUri; + HttpApiUris = httpApiUris; + Id = id; + InstanceId = instanceId; + Management = management; + Password = password; + Port = port; + ProjectId = projectId; + Uri = uri; + Uris = uris; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetRabbitmqInstance.cs b/sdk/dotnet/GetRabbitmqInstance.cs new file mode 100644 index 0000000..4cbbba0 --- /dev/null +++ b/sdk/dotnet/GetRabbitmqInstance.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetRabbitmqInstance + { + /// + /// RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetRabbitmqInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getRabbitmqInstance:getRabbitmqInstance", args ?? new GetRabbitmqInstanceArgs(), options.WithDefaults()); + + /// + /// RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRabbitmqInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRabbitmqInstance:getRabbitmqInstance", args ?? new GetRabbitmqInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_rabbitmq_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRabbitmqInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRabbitmqInstance:getRabbitmqInstance", args ?? new GetRabbitmqInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetRabbitmqInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetRabbitmqInstanceArgs() + { + } + public static new GetRabbitmqInstanceArgs Empty => new GetRabbitmqInstanceArgs(); + } + + public sealed class GetRabbitmqInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetRabbitmqInstanceInvokeArgs() + { + } + public static new GetRabbitmqInstanceInvokeArgs Empty => new GetRabbitmqInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetRabbitmqInstanceResult + { + public readonly string CfGuid; + public readonly string CfOrganizationGuid; + public readonly string CfSpaceGuid; + public readonly string DashboardUrl; + public readonly string Id; + public readonly string ImageUrl; + /// + /// ID of the RabbitMQ instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + public readonly Outputs.GetRabbitmqInstanceParametersResult Parameters; + /// + /// The selected plan ID. + /// + public readonly string PlanId; + /// + /// The selected plan name. + /// + public readonly string PlanName; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The service version. + /// + public readonly string Version; + + [OutputConstructor] + private GetRabbitmqInstanceResult( + string cfGuid, + + string cfOrganizationGuid, + + string cfSpaceGuid, + + string dashboardUrl, + + string id, + + string imageUrl, + + string instanceId, + + string name, + + Outputs.GetRabbitmqInstanceParametersResult parameters, + + string planId, + + string planName, + + string projectId, + + string version) + { + CfGuid = cfGuid; + CfOrganizationGuid = cfOrganizationGuid; + CfSpaceGuid = cfSpaceGuid; + DashboardUrl = dashboardUrl; + Id = id; + ImageUrl = imageUrl; + InstanceId = instanceId; + Name = name; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetRedisCredential.cs b/sdk/dotnet/GetRedisCredential.cs new file mode 100644 index 0000000..72058a4 --- /dev/null +++ b/sdk/dotnet/GetRedisCredential.cs @@ -0,0 +1,181 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetRedisCredential + { + /// + /// Redis credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetRedisCredentialArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getRedisCredential:getRedisCredential", args ?? new GetRedisCredentialArgs(), options.WithDefaults()); + + /// + /// Redis credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRedisCredentialInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRedisCredential:getRedisCredential", args ?? new GetRedisCredentialInvokeArgs(), options.WithDefaults()); + + /// + /// Redis credential data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_credential" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// credential_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRedisCredentialInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRedisCredential:getRedisCredential", args ?? new GetRedisCredentialInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetRedisCredentialArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public string CredentialId { get; set; } = null!; + + /// + /// ID of the Redis instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetRedisCredentialArgs() + { + } + public static new GetRedisCredentialArgs Empty => new GetRedisCredentialArgs(); + } + + public sealed class GetRedisCredentialInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId", required: true)] + public Input CredentialId { get; set; } = null!; + + /// + /// ID of the Redis instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetRedisCredentialInvokeArgs() + { + } + public static new GetRedisCredentialInvokeArgs Empty => new GetRedisCredentialInvokeArgs(); + } + + + [OutputType] + public sealed class GetRedisCredentialResult + { + /// + /// The credential's ID. + /// + public readonly string CredentialId; + public readonly string Host; + public readonly ImmutableArray Hosts; + public readonly string Id; + /// + /// ID of the Redis instance. + /// + public readonly string InstanceId; + public readonly string LoadBalancedHost; + public readonly string Password; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// Connection URI. + /// + public readonly string Uri; + public readonly string Username; + + [OutputConstructor] + private GetRedisCredentialResult( + string credentialId, + + string host, + + ImmutableArray hosts, + + string id, + + string instanceId, + + string loadBalancedHost, + + string password, + + int port, + + string projectId, + + string uri, + + string username) + { + CredentialId = credentialId; + Host = host; + Hosts = hosts; + Id = id; + InstanceId = instanceId; + LoadBalancedHost = loadBalancedHost; + Password = password; + Port = port; + ProjectId = projectId; + Uri = uri; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetRedisInstance.cs b/sdk/dotnet/GetRedisInstance.cs new file mode 100644 index 0000000..039acaa --- /dev/null +++ b/sdk/dotnet/GetRedisInstance.cs @@ -0,0 +1,180 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetRedisInstance + { + /// + /// Redis instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetRedisInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getRedisInstance:getRedisInstance", args ?? new GetRedisInstanceArgs(), options.WithDefaults()); + + /// + /// Redis instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRedisInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRedisInstance:getRedisInstance", args ?? new GetRedisInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// Redis instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_redis_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetRedisInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getRedisInstance:getRedisInstance", args ?? new GetRedisInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetRedisInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Redis instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetRedisInstanceArgs() + { + } + public static new GetRedisInstanceArgs Empty => new GetRedisInstanceArgs(); + } + + public sealed class GetRedisInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Redis instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetRedisInstanceInvokeArgs() + { + } + public static new GetRedisInstanceInvokeArgs Empty => new GetRedisInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetRedisInstanceResult + { + public readonly string CfGuid; + public readonly string CfOrganizationGuid; + public readonly string CfSpaceGuid; + public readonly string DashboardUrl; + public readonly string Id; + public readonly string ImageUrl; + /// + /// ID of the Redis instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + public readonly Outputs.GetRedisInstanceParametersResult Parameters; + /// + /// The selected plan ID. + /// + public readonly string PlanId; + /// + /// The selected plan name. + /// + public readonly string PlanName; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The service version. + /// + public readonly string Version; + + [OutputConstructor] + private GetRedisInstanceResult( + string cfGuid, + + string cfOrganizationGuid, + + string cfSpaceGuid, + + string dashboardUrl, + + string id, + + string imageUrl, + + string instanceId, + + string name, + + Outputs.GetRedisInstanceParametersResult parameters, + + string planId, + + string planName, + + string projectId, + + string version) + { + CfGuid = cfGuid; + CfOrganizationGuid = cfOrganizationGuid; + CfSpaceGuid = cfSpaceGuid; + DashboardUrl = dashboardUrl; + Id = id; + ImageUrl = imageUrl; + InstanceId = instanceId; + Name = name; + Parameters = parameters; + PlanId = planId; + PlanName = planName; + ProjectId = projectId; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetResourcemanagerProject.cs b/sdk/dotnet/GetResourcemanagerProject.cs new file mode 100644 index 0000000..31c6475 --- /dev/null +++ b/sdk/dotnet/GetResourcemanagerProject.cs @@ -0,0 +1,149 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetResourcemanagerProject + { + /// + /// Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_resourcemanager_project" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// container_id = "example-container-abc123" + /// } + /// ``` + /// + public static Task InvokeAsync(GetResourcemanagerProjectArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getResourcemanagerProject:getResourcemanagerProject", args ?? new GetResourcemanagerProjectArgs(), options.WithDefaults()); + + /// + /// Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_resourcemanager_project" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// container_id = "example-container-abc123" + /// } + /// ``` + /// + public static Output Invoke(GetResourcemanagerProjectInvokeArgs? args = null, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getResourcemanagerProject:getResourcemanagerProject", args ?? new GetResourcemanagerProjectInvokeArgs(), options.WithDefaults()); + + /// + /// Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_resourcemanager_project" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// container_id = "example-container-abc123" + /// } + /// ``` + /// + public static Output Invoke(GetResourcemanagerProjectInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getResourcemanagerProject:getResourcemanagerProject", args ?? new GetResourcemanagerProjectInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetResourcemanagerProjectArgs : global::Pulumi.InvokeArgs + { + /// + /// Project container ID. Globally unique, user-friendly identifier. + /// + [Input("containerId")] + public string? ContainerId { get; set; } + + /// + /// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + /// + [Input("projectId")] + public string? ProjectId { get; set; } + + public GetResourcemanagerProjectArgs() + { + } + public static new GetResourcemanagerProjectArgs Empty => new GetResourcemanagerProjectArgs(); + } + + public sealed class GetResourcemanagerProjectInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Project container ID. Globally unique, user-friendly identifier. + /// + [Input("containerId")] + public Input? ContainerId { get; set; } + + /// + /// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + public GetResourcemanagerProjectInvokeArgs() + { + } + public static new GetResourcemanagerProjectInvokeArgs Empty => new GetResourcemanagerProjectInvokeArgs(); + } + + + [OutputType] + public sealed class GetResourcemanagerProjectResult + { + /// + /// Project container ID. Globally unique, user-friendly identifier. + /// + public readonly string? ContainerId; + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64} + /// + public readonly ImmutableDictionary Labels; + /// + /// Project name. + /// + public readonly string Name; + /// + /// Parent resource identifier. Both container ID (user-friendly) and UUID are supported + /// + public readonly string ParentContainerId; + /// + /// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + /// + public readonly string? ProjectId; + + [OutputConstructor] + private GetResourcemanagerProjectResult( + string? containerId, + + string id, + + ImmutableDictionary labels, + + string name, + + string parentContainerId, + + string? projectId) + { + ContainerId = containerId; + Id = id; + Labels = labels; + Name = name; + ParentContainerId = parentContainerId; + ProjectId = projectId; + } + } +} diff --git a/sdk/dotnet/GetSecretsmanagerInstance.cs b/sdk/dotnet/GetSecretsmanagerInstance.cs new file mode 100644 index 0000000..3ea13a8 --- /dev/null +++ b/sdk/dotnet/GetSecretsmanagerInstance.cs @@ -0,0 +1,142 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSecretsmanagerInstance + { + /// + /// Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSecretsmanagerInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", args ?? new GetSecretsmanagerInstanceArgs(), options.WithDefaults()); + + /// + /// Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecretsmanagerInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", args ?? new GetSecretsmanagerInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecretsmanagerInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", args ?? new GetSecretsmanagerInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSecretsmanagerInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetSecretsmanagerInstanceArgs() + { + } + public static new GetSecretsmanagerInstanceArgs Empty => new GetSecretsmanagerInstanceArgs(); + } + + public sealed class GetSecretsmanagerInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetSecretsmanagerInstanceInvokeArgs() + { + } + public static new GetSecretsmanagerInstanceInvokeArgs Empty => new GetSecretsmanagerInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetSecretsmanagerInstanceResult + { + /// + /// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + /// + public readonly ImmutableArray Acls; + public readonly string Id; + /// + /// ID of the Secrets Manager instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + + [OutputConstructor] + private GetSecretsmanagerInstanceResult( + ImmutableArray acls, + + string id, + + string instanceId, + + string name, + + string projectId) + { + Acls = acls; + Id = id; + InstanceId = instanceId; + Name = name; + ProjectId = projectId; + } + } +} diff --git a/sdk/dotnet/GetSecretsmanagerUser.cs b/sdk/dotnet/GetSecretsmanagerUser.cs new file mode 100644 index 0000000..7292a28 --- /dev/null +++ b/sdk/dotnet/GetSecretsmanagerUser.cs @@ -0,0 +1,171 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSecretsmanagerUser + { + /// + /// Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSecretsmanagerUserArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", args ?? new GetSecretsmanagerUserArgs(), options.WithDefaults()); + + /// + /// Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecretsmanagerUserInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", args ?? new GetSecretsmanagerUserInvokeArgs(), options.WithDefaults()); + + /// + /// Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_secretsmanager_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecretsmanagerUserInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", args ?? new GetSecretsmanagerUserInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSecretsmanagerUserArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The user's ID. + /// + [Input("userId", required: true)] + public string UserId { get; set; } = null!; + + public GetSecretsmanagerUserArgs() + { + } + public static new GetSecretsmanagerUserArgs Empty => new GetSecretsmanagerUserArgs(); + } + + public sealed class GetSecretsmanagerUserInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The user's ID. + /// + [Input("userId", required: true)] + public Input UserId { get; set; } = null!; + + public GetSecretsmanagerUserInvokeArgs() + { + } + public static new GetSecretsmanagerUserInvokeArgs Empty => new GetSecretsmanagerUserInvokeArgs(); + } + + + [OutputType] + public sealed class GetSecretsmanagerUserResult + { + /// + /// A user chosen description to differentiate between multiple users. Can't be changed after creation. + /// + public readonly string Description; + public readonly string Id; + /// + /// ID of the Secrets Manager instance. + /// + public readonly string InstanceId; + /// + /// STACKIT Project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The user's ID. + /// + public readonly string UserId; + /// + /// An auto-generated user name. + /// + public readonly string Username; + /// + /// If true, the user has writeaccess to the secrets engine. + /// + public readonly bool WriteEnabled; + + [OutputConstructor] + private GetSecretsmanagerUserResult( + string description, + + string id, + + string instanceId, + + string projectId, + + string userId, + + string username, + + bool writeEnabled) + { + Description = description; + Id = id; + InstanceId = instanceId; + ProjectId = projectId; + UserId = userId; + Username = username; + WriteEnabled = writeEnabled; + } + } +} diff --git a/sdk/dotnet/GetSecurityGroup.cs b/sdk/dotnet/GetSecurityGroup.cs new file mode 100644 index 0000000..d62acc1 --- /dev/null +++ b/sdk/dotnet/GetSecurityGroup.cs @@ -0,0 +1,156 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSecurityGroup + { + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSecurityGroupArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSecurityGroup:getSecurityGroup", args ?? new GetSecurityGroupArgs(), options.WithDefaults()); + + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecurityGroupInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecurityGroup:getSecurityGroup", args ?? new GetSecurityGroupInvokeArgs(), options.WithDefaults()); + + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecurityGroupInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecurityGroup:getSecurityGroup", args ?? new GetSecurityGroupInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSecurityGroupArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the security group is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The security group ID. + /// + [Input("securityGroupId", required: true)] + public string SecurityGroupId { get; set; } = null!; + + public GetSecurityGroupArgs() + { + } + public static new GetSecurityGroupArgs Empty => new GetSecurityGroupArgs(); + } + + public sealed class GetSecurityGroupInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the security group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The security group ID. + /// + [Input("securityGroupId", required: true)] + public Input SecurityGroupId { get; set; } = null!; + + public GetSecurityGroupInvokeArgs() + { + } + public static new GetSecurityGroupInvokeArgs Empty => new GetSecurityGroupInvokeArgs(); + } + + + [OutputType] + public sealed class GetSecurityGroupResult + { + /// + /// The description of the security group. + /// + public readonly string Description; + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The name of the security group. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the security group is associated. + /// + public readonly string ProjectId; + /// + /// The security group ID. + /// + public readonly string SecurityGroupId; + /// + /// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + /// + public readonly bool Stateful; + + [OutputConstructor] + private GetSecurityGroupResult( + string description, + + string id, + + ImmutableDictionary labels, + + string name, + + string projectId, + + string securityGroupId, + + bool stateful) + { + Description = description; + Id = id; + Labels = labels; + Name = name; + ProjectId = projectId; + SecurityGroupId = securityGroupId; + Stateful = stateful; + } + } +} diff --git a/sdk/dotnet/GetSecurityGroupRule.cs b/sdk/dotnet/GetSecurityGroupRule.cs new file mode 100644 index 0000000..2ae9e3c --- /dev/null +++ b/sdk/dotnet/GetSecurityGroupRule.cs @@ -0,0 +1,206 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSecurityGroupRule + { + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group_rule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_rule_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSecurityGroupRuleArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSecurityGroupRule:getSecurityGroupRule", args ?? new GetSecurityGroupRuleArgs(), options.WithDefaults()); + + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group_rule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_rule_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecurityGroupRuleInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecurityGroupRule:getSecurityGroupRule", args ?? new GetSecurityGroupRuleInvokeArgs(), options.WithDefaults()); + + /// + /// Security group datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_security_group_rule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// security_group_rule_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSecurityGroupRuleInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSecurityGroupRule:getSecurityGroupRule", args ?? new GetSecurityGroupRuleInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSecurityGroupRuleArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the security group rule is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The security group ID. + /// + [Input("securityGroupId", required: true)] + public string SecurityGroupId { get; set; } = null!; + + /// + /// The security group rule ID. + /// + [Input("securityGroupRuleId", required: true)] + public string SecurityGroupRuleId { get; set; } = null!; + + public GetSecurityGroupRuleArgs() + { + } + public static new GetSecurityGroupRuleArgs Empty => new GetSecurityGroupRuleArgs(); + } + + public sealed class GetSecurityGroupRuleInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the security group rule is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The security group ID. + /// + [Input("securityGroupId", required: true)] + public Input SecurityGroupId { get; set; } = null!; + + /// + /// The security group rule ID. + /// + [Input("securityGroupRuleId", required: true)] + public Input SecurityGroupRuleId { get; set; } = null!; + + public GetSecurityGroupRuleInvokeArgs() + { + } + public static new GetSecurityGroupRuleInvokeArgs Empty => new GetSecurityGroupRuleInvokeArgs(); + } + + + [OutputType] + public sealed class GetSecurityGroupRuleResult + { + /// + /// The description of the security group rule. + /// + public readonly string Description; + /// + /// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + /// + public readonly string Direction; + /// + /// The ethertype which the rule should match. + /// + public readonly string EtherType; + /// + /// ICMP Parameters. + /// + public readonly Outputs.GetSecurityGroupRuleIcmpParametersResult IcmpParameters; + public readonly string Id; + /// + /// The remote IP range which the rule should match. + /// + public readonly string IpRange; + /// + /// The range of ports. + /// + public readonly Outputs.GetSecurityGroupRulePortRangeResult PortRange; + /// + /// STACKIT project ID to which the security group rule is associated. + /// + public readonly string ProjectId; + /// + /// The internet protocol which the rule should match. + /// + public readonly Outputs.GetSecurityGroupRuleProtocolResult Protocol; + /// + /// The remote security group which the rule should match. + /// + public readonly string RemoteSecurityGroupId; + /// + /// The security group ID. + /// + public readonly string SecurityGroupId; + /// + /// The security group rule ID. + /// + public readonly string SecurityGroupRuleId; + + [OutputConstructor] + private GetSecurityGroupRuleResult( + string description, + + string direction, + + string etherType, + + Outputs.GetSecurityGroupRuleIcmpParametersResult icmpParameters, + + string id, + + string ipRange, + + Outputs.GetSecurityGroupRulePortRangeResult portRange, + + string projectId, + + Outputs.GetSecurityGroupRuleProtocolResult protocol, + + string remoteSecurityGroupId, + + string securityGroupId, + + string securityGroupRuleId) + { + Description = description; + Direction = direction; + EtherType = etherType; + IcmpParameters = icmpParameters; + Id = id; + IpRange = ipRange; + PortRange = portRange; + ProjectId = projectId; + Protocol = protocol; + RemoteSecurityGroupId = remoteSecurityGroupId; + SecurityGroupId = securityGroupId; + SecurityGroupRuleId = securityGroupRuleId; + } + } +} diff --git a/sdk/dotnet/GetServer.cs b/sdk/dotnet/GetServer.cs new file mode 100644 index 0000000..92fd940 --- /dev/null +++ b/sdk/dotnet/GetServer.cs @@ -0,0 +1,219 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServer + { + /// + /// Server datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetServerArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServer:getServer", args ?? new GetServerArgs(), options.WithDefaults()); + + /// + /// Server datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServer:getServer", args ?? new GetServerInvokeArgs(), options.WithDefaults()); + + /// + /// Server datasource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServer:getServer", args ?? new GetServerInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServerArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The server ID. + /// + [Input("serverId", required: true)] + public string ServerId { get; set; } = null!; + + public GetServerArgs() + { + } + public static new GetServerArgs Empty => new GetServerArgs(); + } + + public sealed class GetServerInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The server ID. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public GetServerInvokeArgs() + { + } + public static new GetServerInvokeArgs Empty => new GetServerInvokeArgs(); + } + + + [OutputType] + public sealed class GetServerResult + { + /// + /// The affinity group the server is assigned to. + /// + public readonly string AffinityGroup; + /// + /// The availability zone of the server. + /// + public readonly string AvailabilityZone; + /// + /// The boot volume for the server + /// + public readonly Outputs.GetServerBootVolumeResult BootVolume; + /// + /// Date-time when the server was created + /// + public readonly string CreatedAt; + public readonly string Id; + /// + /// The image ID to be used for an ephemeral disk on the server. + /// + public readonly string ImageId; + /// + /// The name of the keypair used during server creation. + /// + public readonly string KeypairName; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// Date-time when the server was launched + /// + public readonly string LaunchedAt; + /// + /// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + /// + public readonly string MachineType; + /// + /// The name of the server. + /// + public readonly string Name; + /// + /// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + /// + public readonly ImmutableArray NetworkInterfaces; + /// + /// STACKIT project ID to which the server is associated. + /// + public readonly string ProjectId; + /// + /// The server ID. + /// + public readonly string ServerId; + /// + /// Date-time when the server was updated + /// + public readonly string UpdatedAt; + /// + /// User data that is passed via cloud-init to the server. + /// + public readonly string UserData; + + [OutputConstructor] + private GetServerResult( + string affinityGroup, + + string availabilityZone, + + Outputs.GetServerBootVolumeResult bootVolume, + + string createdAt, + + string id, + + string imageId, + + string keypairName, + + ImmutableDictionary labels, + + string launchedAt, + + string machineType, + + string name, + + ImmutableArray networkInterfaces, + + string projectId, + + string serverId, + + string updatedAt, + + string userData) + { + AffinityGroup = affinityGroup; + AvailabilityZone = availabilityZone; + BootVolume = bootVolume; + CreatedAt = createdAt; + Id = id; + ImageId = imageId; + KeypairName = keypairName; + Labels = labels; + LaunchedAt = launchedAt; + MachineType = machineType; + Name = name; + NetworkInterfaces = networkInterfaces; + ProjectId = projectId; + ServerId = serverId; + UpdatedAt = updatedAt; + UserData = userData; + } + } +} diff --git a/sdk/dotnet/GetServerBackupSchedule.cs b/sdk/dotnet/GetServerBackupSchedule.cs new file mode 100644 index 0000000..ac0542f --- /dev/null +++ b/sdk/dotnet/GetServerBackupSchedule.cs @@ -0,0 +1,203 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServerBackupSchedule + { + /// + /// Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// backup_schedule_id = xxxxx + /// } + /// ``` + /// + public static Task InvokeAsync(GetServerBackupScheduleArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServerBackupSchedule:getServerBackupSchedule", args ?? new GetServerBackupScheduleArgs(), options.WithDefaults()); + + /// + /// Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// backup_schedule_id = xxxxx + /// } + /// ``` + /// + public static Output Invoke(GetServerBackupScheduleInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerBackupSchedule:getServerBackupSchedule", args ?? new GetServerBackupScheduleInvokeArgs(), options.WithDefaults()); + + /// + /// Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// backup_schedule_id = xxxxx + /// } + /// ``` + /// + public static Output Invoke(GetServerBackupScheduleInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerBackupSchedule:getServerBackupSchedule", args ?? new GetServerBackupScheduleInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServerBackupScheduleArgs : global::Pulumi.InvokeArgs + { + /// + /// Backup schedule ID. + /// + [Input("backupScheduleId", required: true)] + public int BackupScheduleId { get; set; } + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// Server ID for the backup schedule. + /// + [Input("serverId", required: true)] + public string ServerId { get; set; } = null!; + + public GetServerBackupScheduleArgs() + { + } + public static new GetServerBackupScheduleArgs Empty => new GetServerBackupScheduleArgs(); + } + + public sealed class GetServerBackupScheduleInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Backup schedule ID. + /// + [Input("backupScheduleId", required: true)] + public Input BackupScheduleId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Server ID for the backup schedule. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public GetServerBackupScheduleInvokeArgs() + { + } + public static new GetServerBackupScheduleInvokeArgs Empty => new GetServerBackupScheduleInvokeArgs(); + } + + + [OutputType] + public sealed class GetServerBackupScheduleResult + { + /// + /// Backup schedule details for the backups. + /// + public readonly Outputs.GetServerBackupScheduleBackupPropertiesResult BackupProperties; + /// + /// Backup schedule ID. + /// + public readonly int BackupScheduleId; + /// + /// Is the backup schedule enabled or disabled. + /// + public readonly bool Enabled; + public readonly string Id; + /// + /// The schedule name. + /// + public readonly string Name; + /// + /// STACKIT Project ID to which the server is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Backup schedule described in `rrule` (recurrence rule) format. + /// + public readonly string Rrule; + /// + /// Server ID for the backup schedule. + /// + public readonly string ServerId; + + [OutputConstructor] + private GetServerBackupScheduleResult( + Outputs.GetServerBackupScheduleBackupPropertiesResult backupProperties, + + int backupScheduleId, + + bool enabled, + + string id, + + string name, + + string projectId, + + string? region, + + string rrule, + + string serverId) + { + BackupProperties = backupProperties; + BackupScheduleId = backupScheduleId; + Enabled = enabled; + Id = id; + Name = name; + ProjectId = projectId; + Region = region; + Rrule = rrule; + ServerId = serverId; + } + } +} diff --git a/sdk/dotnet/GetServerBackupSchedules.cs b/sdk/dotnet/GetServerBackupSchedules.cs new file mode 100644 index 0000000..066b054 --- /dev/null +++ b/sdk/dotnet/GetServerBackupSchedules.cs @@ -0,0 +1,157 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServerBackupSchedules + { + /// + /// Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetServerBackupSchedulesArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServerBackupSchedules:getServerBackupSchedules", args ?? new GetServerBackupSchedulesArgs(), options.WithDefaults()); + + /// + /// Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerBackupSchedulesInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerBackupSchedules:getServerBackupSchedules", args ?? new GetServerBackupSchedulesInvokeArgs(), options.WithDefaults()); + + /// + /// Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_backup_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerBackupSchedulesInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerBackupSchedules:getServerBackupSchedules", args ?? new GetServerBackupSchedulesInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServerBackupSchedulesArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// Server ID (UUID) to which the backup schedule is associated. + /// + [Input("serverId", required: true)] + public string ServerId { get; set; } = null!; + + public GetServerBackupSchedulesArgs() + { + } + public static new GetServerBackupSchedulesArgs Empty => new GetServerBackupSchedulesArgs(); + } + + public sealed class GetServerBackupSchedulesInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Server ID (UUID) to which the backup schedule is associated. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public GetServerBackupSchedulesInvokeArgs() + { + } + public static new GetServerBackupSchedulesInvokeArgs Empty => new GetServerBackupSchedulesInvokeArgs(); + } + + + [OutputType] + public sealed class GetServerBackupSchedulesResult + { + public readonly string Id; + public readonly ImmutableArray Items; + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Server ID (UUID) to which the backup schedule is associated. + /// + public readonly string ServerId; + + [OutputConstructor] + private GetServerBackupSchedulesResult( + string id, + + ImmutableArray items, + + string projectId, + + string? region, + + string serverId) + { + Id = id; + Items = items; + ProjectId = projectId; + Region = region; + ServerId = serverId; + } + } +} diff --git a/sdk/dotnet/GetServerUpdateSchedule.cs b/sdk/dotnet/GetServerUpdateSchedule.cs new file mode 100644 index 0000000..3bb992e --- /dev/null +++ b/sdk/dotnet/GetServerUpdateSchedule.cs @@ -0,0 +1,203 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServerUpdateSchedule + { + /// + /// Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// update_schedule_id = xxxxx + /// } + /// ``` + /// + public static Task InvokeAsync(GetServerUpdateScheduleArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", args ?? new GetServerUpdateScheduleArgs(), options.WithDefaults()); + + /// + /// Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// update_schedule_id = xxxxx + /// } + /// ``` + /// + public static Output Invoke(GetServerUpdateScheduleInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", args ?? new GetServerUpdateScheduleInvokeArgs(), options.WithDefaults()); + + /// + /// Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedule" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// update_schedule_id = xxxxx + /// } + /// ``` + /// + public static Output Invoke(GetServerUpdateScheduleInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", args ?? new GetServerUpdateScheduleInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServerUpdateScheduleArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// Server ID for the update schedule. + /// + [Input("serverId", required: true)] + public string ServerId { get; set; } = null!; + + /// + /// Update schedule ID. + /// + [Input("updateScheduleId", required: true)] + public int UpdateScheduleId { get; set; } + + public GetServerUpdateScheduleArgs() + { + } + public static new GetServerUpdateScheduleArgs Empty => new GetServerUpdateScheduleArgs(); + } + + public sealed class GetServerUpdateScheduleInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Server ID for the update schedule. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + /// + /// Update schedule ID. + /// + [Input("updateScheduleId", required: true)] + public Input UpdateScheduleId { get; set; } = null!; + + public GetServerUpdateScheduleInvokeArgs() + { + } + public static new GetServerUpdateScheduleInvokeArgs Empty => new GetServerUpdateScheduleInvokeArgs(); + } + + + [OutputType] + public sealed class GetServerUpdateScheduleResult + { + /// + /// Is the update schedule enabled or disabled. + /// + public readonly bool Enabled; + public readonly string Id; + /// + /// Maintenance window [1..24]. + /// + public readonly int MaintenanceWindow; + /// + /// The schedule name. + /// + public readonly string Name; + /// + /// STACKIT Project ID to which the server is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Update schedule described in `rrule` (recurrence rule) format. + /// + public readonly string Rrule; + /// + /// Server ID for the update schedule. + /// + public readonly string ServerId; + /// + /// Update schedule ID. + /// + public readonly int UpdateScheduleId; + + [OutputConstructor] + private GetServerUpdateScheduleResult( + bool enabled, + + string id, + + int maintenanceWindow, + + string name, + + string projectId, + + string? region, + + string rrule, + + string serverId, + + int updateScheduleId) + { + Enabled = enabled; + Id = id; + MaintenanceWindow = maintenanceWindow; + Name = name; + ProjectId = projectId; + Region = region; + Rrule = rrule; + ServerId = serverId; + UpdateScheduleId = updateScheduleId; + } + } +} diff --git a/sdk/dotnet/GetServerUpdateSchedules.cs b/sdk/dotnet/GetServerUpdateSchedules.cs new file mode 100644 index 0000000..369d762 --- /dev/null +++ b/sdk/dotnet/GetServerUpdateSchedules.cs @@ -0,0 +1,157 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServerUpdateSchedules + { + /// + /// Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetServerUpdateSchedulesArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", args ?? new GetServerUpdateSchedulesArgs(), options.WithDefaults()); + + /// + /// Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerUpdateSchedulesInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", args ?? new GetServerUpdateSchedulesInvokeArgs(), options.WithDefaults()); + + /// + /// Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_server_update_schedules" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// server_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetServerUpdateSchedulesInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", args ?? new GetServerUpdateSchedulesInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServerUpdateSchedulesArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// Server ID (UUID) to which the update schedule is associated. + /// + [Input("serverId", required: true)] + public string ServerId { get; set; } = null!; + + public GetServerUpdateSchedulesArgs() + { + } + public static new GetServerUpdateSchedulesArgs Empty => new GetServerUpdateSchedulesArgs(); + } + + public sealed class GetServerUpdateSchedulesInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Server ID (UUID) to which the update schedule is associated. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public GetServerUpdateSchedulesInvokeArgs() + { + } + public static new GetServerUpdateSchedulesInvokeArgs Empty => new GetServerUpdateSchedulesInvokeArgs(); + } + + + [OutputType] + public sealed class GetServerUpdateSchedulesResult + { + public readonly string Id; + public readonly ImmutableArray Items; + /// + /// STACKIT Project ID (UUID) to which the server is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Server ID (UUID) to which the update schedule is associated. + /// + public readonly string ServerId; + + [OutputConstructor] + private GetServerUpdateSchedulesResult( + string id, + + ImmutableArray items, + + string projectId, + + string? region, + + string serverId) + { + Id = id; + Items = items; + ProjectId = projectId; + Region = region; + ServerId = serverId; + } + } +} diff --git a/sdk/dotnet/GetServiceAccount.cs b/sdk/dotnet/GetServiceAccount.cs new file mode 100644 index 0000000..0102529 --- /dev/null +++ b/sdk/dotnet/GetServiceAccount.cs @@ -0,0 +1,135 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetServiceAccount + { + /// + /// Service account data source schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_service_account" "sa" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// email = "sa01-8565oq1@sa.stackit.cloud" + /// } + /// ``` + /// + public static Task InvokeAsync(GetServiceAccountArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getServiceAccount:getServiceAccount", args ?? new GetServiceAccountArgs(), options.WithDefaults()); + + /// + /// Service account data source schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_service_account" "sa" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// email = "sa01-8565oq1@sa.stackit.cloud" + /// } + /// ``` + /// + public static Output Invoke(GetServiceAccountInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServiceAccount:getServiceAccount", args ?? new GetServiceAccountInvokeArgs(), options.WithDefaults()); + + /// + /// Service account data source schema. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_service_account" "sa" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// email = "sa01-8565oq1@sa.stackit.cloud" + /// } + /// ``` + /// + public static Output Invoke(GetServiceAccountInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getServiceAccount:getServiceAccount", args ?? new GetServiceAccountInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetServiceAccountArgs : global::Pulumi.InvokeArgs + { + /// + /// Email of the service account. + /// + [Input("email", required: true)] + public string Email { get; set; } = null!; + + /// + /// STACKIT project ID to which the service account is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + public GetServiceAccountArgs() + { + } + public static new GetServiceAccountArgs Empty => new GetServiceAccountArgs(); + } + + public sealed class GetServiceAccountInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// Email of the service account. + /// + [Input("email", required: true)] + public Input Email { get; set; } = null!; + + /// + /// STACKIT project ID to which the service account is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GetServiceAccountInvokeArgs() + { + } + public static new GetServiceAccountInvokeArgs Empty => new GetServiceAccountInvokeArgs(); + } + + + [OutputType] + public sealed class GetServiceAccountResult + { + /// + /// Email of the service account. + /// + public readonly string Email; + public readonly string Id; + /// + /// Name of the service account. + /// + public readonly string Name; + /// + /// STACKIT project ID to which the service account is associated. + /// + public readonly string ProjectId; + + [OutputConstructor] + private GetServiceAccountResult( + string email, + + string id, + + string name, + + string projectId) + { + Email = email; + Id = id; + Name = name; + ProjectId = projectId; + } + } +} diff --git a/sdk/dotnet/GetSkeCluster.cs b/sdk/dotnet/GetSkeCluster.cs new file mode 100644 index 0000000..6855e11 --- /dev/null +++ b/sdk/dotnet/GetSkeCluster.cs @@ -0,0 +1,219 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSkeCluster + { + /// + /// SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_ske_cluster" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSkeClusterArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSkeCluster:getSkeCluster", args ?? new GetSkeClusterArgs(), options.WithDefaults()); + + /// + /// SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_ske_cluster" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Output Invoke(GetSkeClusterInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSkeCluster:getSkeCluster", args ?? new GetSkeClusterInvokeArgs(), options.WithDefaults()); + + /// + /// SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_ske_cluster" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// name = "example-name" + /// } + /// ``` + /// + public static Output Invoke(GetSkeClusterInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSkeCluster:getSkeCluster", args ?? new GetSkeClusterInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSkeClusterArgs : global::Pulumi.InvokeArgs + { + /// + /// The cluster name. + /// + [Input("name", required: true)] + public string Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetSkeClusterArgs() + { + } + public static new GetSkeClusterArgs Empty => new GetSkeClusterArgs(); + } + + public sealed class GetSkeClusterInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// The cluster name. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetSkeClusterInvokeArgs() + { + } + public static new GetSkeClusterInvokeArgs Empty => new GetSkeClusterInvokeArgs(); + } + + + [OutputType] + public sealed class GetSkeClusterResult + { + /// + /// DEPRECATED as of Kubernetes 1.25+ + /// Flag to specify if privileged mode for containers is enabled or not. + /// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + /// + public readonly bool AllowPrivilegedContainers; + /// + /// The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + /// + public readonly ImmutableArray EgressAddressRanges; + /// + /// A single extensions block as defined below + /// + public readonly Outputs.GetSkeClusterExtensionsResult Extensions; + /// + /// One or more hibernation block as defined below. + /// + public readonly ImmutableArray Hibernations; + public readonly string Id; + /// + /// Kubernetes version. This field is deprecated, use `kubernetes_version_used` instead + /// + public readonly string KubernetesVersion; + /// + /// The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetes_version_used` field. + /// + public readonly string KubernetesVersionMin; + /// + /// Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15` + /// + public readonly string KubernetesVersionUsed; + /// + /// A single maintenance block as defined below + /// + public readonly Outputs.GetSkeClusterMaintenanceResult Maintenance; + /// + /// The cluster name. + /// + public readonly string Name; + /// + /// Network block as defined below. + /// + public readonly Outputs.GetSkeClusterNetworkResult Network; + /// + /// One or more `node_pool` block as defined below. + /// + public readonly ImmutableArray NodePools; + /// + /// STACKIT project ID to which the cluster is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + + [OutputConstructor] + private GetSkeClusterResult( + bool allowPrivilegedContainers, + + ImmutableArray egressAddressRanges, + + Outputs.GetSkeClusterExtensionsResult extensions, + + ImmutableArray hibernations, + + string id, + + string kubernetesVersion, + + string kubernetesVersionMin, + + string kubernetesVersionUsed, + + Outputs.GetSkeClusterMaintenanceResult maintenance, + + string name, + + Outputs.GetSkeClusterNetworkResult network, + + ImmutableArray nodePools, + + string projectId, + + string? region) + { + AllowPrivilegedContainers = allowPrivilegedContainers; + EgressAddressRanges = egressAddressRanges; + Extensions = extensions; + Hibernations = hibernations; + Id = id; + KubernetesVersion = kubernetesVersion; + KubernetesVersionMin = kubernetesVersionMin; + KubernetesVersionUsed = kubernetesVersionUsed; + Maintenance = maintenance; + Name = name; + Network = network; + NodePools = nodePools; + ProjectId = projectId; + Region = region; + } + } +} diff --git a/sdk/dotnet/GetSqlserverflexInstance.cs b/sdk/dotnet/GetSqlserverflexInstance.cs new file mode 100644 index 0000000..734f275 --- /dev/null +++ b/sdk/dotnet/GetSqlserverflexInstance.cs @@ -0,0 +1,191 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSqlserverflexInstance + { + /// + /// SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSqlserverflexInstanceArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", args ?? new GetSqlserverflexInstanceArgs(), options.WithDefaults()); + + /// + /// SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSqlserverflexInstanceInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", args ?? new GetSqlserverflexInstanceInvokeArgs(), options.WithDefaults()); + + /// + /// SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_instance" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSqlserverflexInstanceInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", args ?? new GetSqlserverflexInstanceInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSqlserverflexInstanceArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + public GetSqlserverflexInstanceArgs() + { + } + public static new GetSqlserverflexInstanceArgs Empty => new GetSqlserverflexInstanceArgs(); + } + + public sealed class GetSqlserverflexInstanceInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public GetSqlserverflexInstanceInvokeArgs() + { + } + public static new GetSqlserverflexInstanceInvokeArgs Empty => new GetSqlserverflexInstanceInvokeArgs(); + } + + + [OutputType] + public sealed class GetSqlserverflexInstanceResult + { + /// + /// The Access Control List (ACL) for the SQLServer Flex instance. + /// + public readonly ImmutableArray Acls; + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + /// + public readonly string BackupSchedule; + public readonly Outputs.GetSqlserverflexInstanceFlavorResult Flavor; + public readonly string Id; + /// + /// ID of the SQLServer Flex instance. + /// + public readonly string InstanceId; + /// + /// Instance name. + /// + public readonly string Name; + /// + /// Custom parameters for the SQLServer Flex instance. + /// + public readonly Outputs.GetSqlserverflexInstanceOptionsResult Options; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + public readonly int Replicas; + public readonly Outputs.GetSqlserverflexInstanceStorageResult Storage; + public readonly string Version; + + [OutputConstructor] + private GetSqlserverflexInstanceResult( + ImmutableArray acls, + + string backupSchedule, + + Outputs.GetSqlserverflexInstanceFlavorResult flavor, + + string id, + + string instanceId, + + string name, + + Outputs.GetSqlserverflexInstanceOptionsResult options, + + string projectId, + + string? region, + + int replicas, + + Outputs.GetSqlserverflexInstanceStorageResult storage, + + string version) + { + Acls = acls; + BackupSchedule = backupSchedule; + Flavor = flavor; + Id = id; + InstanceId = instanceId; + Name = name; + Options = options; + ProjectId = projectId; + Region = region; + Replicas = replicas; + Storage = storage; + Version = version; + } + } +} diff --git a/sdk/dotnet/GetSqlserverflexUser.cs b/sdk/dotnet/GetSqlserverflexUser.cs new file mode 100644 index 0000000..06d8eef --- /dev/null +++ b/sdk/dotnet/GetSqlserverflexUser.cs @@ -0,0 +1,191 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetSqlserverflexUser + { + /// + /// SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetSqlserverflexUserArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getSqlserverflexUser:getSqlserverflexUser", args ?? new GetSqlserverflexUserArgs(), options.WithDefaults()); + + /// + /// SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSqlserverflexUserInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSqlserverflexUser:getSqlserverflexUser", args ?? new GetSqlserverflexUserInvokeArgs(), options.WithDefaults()); + + /// + /// SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_sqlserverflex_user" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// instance_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// user_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetSqlserverflexUserInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getSqlserverflexUser:getSqlserverflexUser", args ?? new GetSqlserverflexUserInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetSqlserverflexUserArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId", required: true)] + public string InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public string? Region { get; set; } + + /// + /// User ID. + /// + [Input("userId", required: true)] + public string UserId { get; set; } = null!; + + public GetSqlserverflexUserArgs() + { + } + public static new GetSqlserverflexUserArgs Empty => new GetSqlserverflexUserArgs(); + } + + public sealed class GetSqlserverflexUserInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// User ID. + /// + [Input("userId", required: true)] + public Input UserId { get; set; } = null!; + + public GetSqlserverflexUserInvokeArgs() + { + } + public static new GetSqlserverflexUserInvokeArgs Empty => new GetSqlserverflexUserInvokeArgs(); + } + + + [OutputType] + public sealed class GetSqlserverflexUserResult + { + public readonly string Host; + public readonly string Id; + /// + /// ID of the SQLServer Flex instance. + /// + public readonly string InstanceId; + public readonly int Port; + /// + /// STACKIT project ID to which the instance is associated. + /// + public readonly string ProjectId; + /// + /// The resource region. If not defined, the provider region is used. + /// + public readonly string? Region; + /// + /// Database access levels for the user. + /// + public readonly ImmutableArray Roles; + /// + /// User ID. + /// + public readonly string UserId; + /// + /// Username of the SQLServer Flex instance. + /// + public readonly string Username; + + [OutputConstructor] + private GetSqlserverflexUserResult( + string host, + + string id, + + string instanceId, + + int port, + + string projectId, + + string? region, + + ImmutableArray roles, + + string userId, + + string username) + { + Host = host; + Id = id; + InstanceId = instanceId; + Port = port; + ProjectId = projectId; + Region = region; + Roles = roles; + UserId = userId; + Username = username; + } + } +} diff --git a/sdk/dotnet/GetVolume.cs b/sdk/dotnet/GetVolume.cs new file mode 100644 index 0000000..872e0e7 --- /dev/null +++ b/sdk/dotnet/GetVolume.cs @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + public static class GetVolume + { + /// + /// Volume resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_volume" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// volume_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Task InvokeAsync(GetVolumeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("stackit:index/getVolume:getVolume", args ?? new GetVolumeArgs(), options.WithDefaults()); + + /// + /// Volume resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_volume" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// volume_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetVolumeInvokeArgs args, InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getVolume:getVolume", args ?? new GetVolumeInvokeArgs(), options.WithDefaults()); + + /// + /// Volume resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ```terraform + /// data "stackit_volume" "example" { + /// project_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// volume_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" + /// } + /// ``` + /// + public static Output Invoke(GetVolumeInvokeArgs args, InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("stackit:index/getVolume:getVolume", args ?? new GetVolumeInvokeArgs(), options.WithDefaults()); + } + + + public sealed class GetVolumeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the volume is associated. + /// + [Input("projectId", required: true)] + public string ProjectId { get; set; } = null!; + + /// + /// The volume ID. + /// + [Input("volumeId", required: true)] + public string VolumeId { get; set; } = null!; + + public GetVolumeArgs() + { + } + public static new GetVolumeArgs Empty => new GetVolumeArgs(); + } + + public sealed class GetVolumeInvokeArgs : global::Pulumi.InvokeArgs + { + /// + /// STACKIT project ID to which the volume is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The volume ID. + /// + [Input("volumeId", required: true)] + public Input VolumeId { get; set; } = null!; + + public GetVolumeInvokeArgs() + { + } + public static new GetVolumeInvokeArgs Empty => new GetVolumeInvokeArgs(); + } + + + [OutputType] + public sealed class GetVolumeResult + { + /// + /// The availability zone of the volume. + /// + public readonly string AvailabilityZone; + /// + /// The description of the volume. + /// + public readonly string Description; + public readonly string Id; + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public readonly ImmutableDictionary Labels; + /// + /// The name of the volume. + /// + public readonly string Name; + /// + /// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + /// + public readonly string PerformanceClass; + /// + /// STACKIT project ID to which the volume is associated. + /// + public readonly string ProjectId; + /// + /// The server ID of the server to which the volume is attached to. + /// + public readonly string ServerId; + /// + /// The size of the volume in GB. It can only be updated to a larger value than the current size + /// + public readonly int Size; + /// + /// The source of the volume. It can be either a volume, an image, a snapshot or a backup + /// + public readonly Outputs.GetVolumeSourceResult Source; + /// + /// The volume ID. + /// + public readonly string VolumeId; + + [OutputConstructor] + private GetVolumeResult( + string availabilityZone, + + string description, + + string id, + + ImmutableDictionary labels, + + string name, + + string performanceClass, + + string projectId, + + string serverId, + + int size, + + Outputs.GetVolumeSourceResult source, + + string volumeId) + { + AvailabilityZone = availabilityZone; + Description = description; + Id = id; + Labels = labels; + Name = name; + PerformanceClass = performanceClass; + ProjectId = projectId; + ServerId = serverId; + Size = size; + Source = source; + VolumeId = volumeId; + } + } +} diff --git a/sdk/dotnet/Git.cs b/sdk/dotnet/Git.cs new file mode 100644 index 0000000..4d8222e --- /dev/null +++ b/sdk/dotnet/Git.cs @@ -0,0 +1,154 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Git Instance resource schema. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/git:Git")] + public partial class Git : global::Pulumi.CustomResource + { + /// + /// ID linked to the git instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Unique name linked to the git instance. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the git instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Url linked to the git instance. + /// + [Output("url")] + public Output Url { get; private set; } = null!; + + /// + /// Version linked to the git instance. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a Git 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 Git(string name, GitArgs args, CustomResourceOptions? options = null) + : base("stackit:index/git:Git", name, args ?? new GitArgs(), MakeResourceOptions(options, "")) + { + } + + private Git(string name, Input id, GitState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/git:Git", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Git 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 Git Get(string name, Input id, GitState? state = null, CustomResourceOptions? options = null) + { + return new Git(name, id, state, options); + } + } + + public sealed class GitArgs : global::Pulumi.ResourceArgs + { + /// + /// Unique name linked to the git instance. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the git instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public GitArgs() + { + } + public static new GitArgs Empty => new GitArgs(); + } + + public sealed class GitState : global::Pulumi.ResourceArgs + { + /// + /// ID linked to the git instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Unique name linked to the git instance. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the git instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Url linked to the git instance. + /// + [Input("url")] + public Input? Url { get; set; } + + /// + /// Version linked to the git instance. + /// + [Input("version")] + public Input? Version { get; set; } + + public GitState() + { + } + public static new GitState Empty => new GitState(); + } +} diff --git a/sdk/dotnet/Image.cs b/sdk/dotnet/Image.cs new file mode 100644 index 0000000..ac17841 --- /dev/null +++ b/sdk/dotnet/Image.cs @@ -0,0 +1,284 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Image resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/image:Image")] + public partial class Image : global::Pulumi.CustomResource + { + /// + /// Representation of an image checksum. + /// + [Output("checksum")] + public Output Checksum { get; private set; } = null!; + + /// + /// Properties to set hardware and scheduling settings for an image. + /// + [Output("config")] + public Output Config { get; private set; } = null!; + + /// + /// The disk format of the image. + /// + [Output("diskFormat")] + public Output DiskFormat { get; private set; } = null!; + + /// + /// The image ID. + /// + [Output("imageId")] + public Output ImageId { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The filepath of the raw image file to be uploaded. + /// + [Output("localFilePath")] + public Output LocalFilePath { get; private set; } = null!; + + /// + /// The minimum disk size of the image in GB. + /// + [Output("minDiskSize")] + public Output MinDiskSize { get; private set; } = null!; + + /// + /// The minimum RAM of the image in MB. + /// + [Output("minRam")] + public Output MinRam { get; private set; } = null!; + + /// + /// The name of the image. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the image is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Whether the image is protected. + /// + [Output("protected")] + public Output Protected { get; private set; } = null!; + + /// + /// The scope of the image. + /// + [Output("scope")] + public Output Scope { get; private set; } = null!; + + + /// + /// Create a Image 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 Image(string name, ImageArgs args, CustomResourceOptions? options = null) + : base("stackit:index/image:Image", name, args ?? new ImageArgs(), MakeResourceOptions(options, "")) + { + } + + private Image(string name, Input id, ImageState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/image:Image", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Image 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 Image Get(string name, Input id, ImageState? state = null, CustomResourceOptions? options = null) + { + return new Image(name, id, state, options); + } + } + + public sealed class ImageArgs : global::Pulumi.ResourceArgs + { + /// + /// Properties to set hardware and scheduling settings for an image. + /// + [Input("config")] + public Input? Config { get; set; } + + /// + /// The disk format of the image. + /// + [Input("diskFormat", required: true)] + public Input DiskFormat { get; set; } = null!; + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The filepath of the raw image file to be uploaded. + /// + [Input("localFilePath", required: true)] + public Input LocalFilePath { get; set; } = null!; + + /// + /// The minimum disk size of the image in GB. + /// + [Input("minDiskSize")] + public Input? MinDiskSize { get; set; } + + /// + /// The minimum RAM of the image in MB. + /// + [Input("minRam")] + public Input? MinRam { get; set; } + + /// + /// The name of the image. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the image is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public ImageArgs() + { + } + public static new ImageArgs Empty => new ImageArgs(); + } + + public sealed class ImageState : global::Pulumi.ResourceArgs + { + /// + /// Representation of an image checksum. + /// + [Input("checksum")] + public Input? Checksum { get; set; } + + /// + /// Properties to set hardware and scheduling settings for an image. + /// + [Input("config")] + public Input? Config { get; set; } + + /// + /// The disk format of the image. + /// + [Input("diskFormat")] + public Input? DiskFormat { get; set; } + + /// + /// The image ID. + /// + [Input("imageId")] + public Input? ImageId { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The filepath of the raw image file to be uploaded. + /// + [Input("localFilePath")] + public Input? LocalFilePath { get; set; } + + /// + /// The minimum disk size of the image in GB. + /// + [Input("minDiskSize")] + public Input? MinDiskSize { get; set; } + + /// + /// The minimum RAM of the image in MB. + /// + [Input("minRam")] + public Input? MinRam { get; set; } + + /// + /// The name of the image. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the image is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Whether the image is protected. + /// + [Input("protected")] + public Input? Protected { get; set; } + + /// + /// The scope of the image. + /// + [Input("scope")] + public Input? Scope { get; set; } + + public ImageState() + { + } + public static new ImageState Empty => new ImageState(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionConfigArgs.cs b/sdk/dotnet/Inputs/CdnDistributionConfigArgs.cs new file mode 100644 index 0000000..00a048b --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionConfigArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// The configured backend for the distribution + /// + [Input("backend", required: true)] + public Input Backend { get; set; } = null!; + + [Input("regions", required: true)] + private InputList? _regions; + + /// + /// The configured regions where content will be hosted + /// + public InputList Regions + { + get => _regions ?? (_regions = new InputList()); + set => _regions = value; + } + + public CdnDistributionConfigArgs() + { + } + public static new CdnDistributionConfigArgs Empty => new CdnDistributionConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionConfigBackendArgs.cs b/sdk/dotnet/Inputs/CdnDistributionConfigBackendArgs.cs new file mode 100644 index 0000000..9347fbe --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionConfigBackendArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionConfigBackendArgs : global::Pulumi.ResourceArgs + { + [Input("originRequestHeaders")] + private InputMap? _originRequestHeaders; + + /// + /// The configured origin request headers for the backend + /// + public InputMap OriginRequestHeaders + { + get => _originRequestHeaders ?? (_originRequestHeaders = new InputMap()); + set => _originRequestHeaders = value; + } + + /// + /// The configured backend type for the distribution + /// + [Input("originUrl", required: true)] + public Input OriginUrl { get; set; } = null!; + + /// + /// The configured backend type. Supported values are: `http`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public CdnDistributionConfigBackendArgs() + { + } + public static new CdnDistributionConfigBackendArgs Empty => new CdnDistributionConfigBackendArgs(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionConfigBackendGetArgs.cs b/sdk/dotnet/Inputs/CdnDistributionConfigBackendGetArgs.cs new file mode 100644 index 0000000..4aa1767 --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionConfigBackendGetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionConfigBackendGetArgs : global::Pulumi.ResourceArgs + { + [Input("originRequestHeaders")] + private InputMap? _originRequestHeaders; + + /// + /// The configured origin request headers for the backend + /// + public InputMap OriginRequestHeaders + { + get => _originRequestHeaders ?? (_originRequestHeaders = new InputMap()); + set => _originRequestHeaders = value; + } + + /// + /// The configured backend type for the distribution + /// + [Input("originUrl", required: true)] + public Input OriginUrl { get; set; } = null!; + + /// + /// The configured backend type. Supported values are: `http`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public CdnDistributionConfigBackendGetArgs() + { + } + public static new CdnDistributionConfigBackendGetArgs Empty => new CdnDistributionConfigBackendGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionConfigGetArgs.cs b/sdk/dotnet/Inputs/CdnDistributionConfigGetArgs.cs new file mode 100644 index 0000000..fa1d3d8 --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionConfigGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The configured backend for the distribution + /// + [Input("backend", required: true)] + public Input Backend { get; set; } = null!; + + [Input("regions", required: true)] + private InputList? _regions; + + /// + /// The configured regions where content will be hosted + /// + public InputList Regions + { + get => _regions ?? (_regions = new InputList()); + set => _regions = value; + } + + public CdnDistributionConfigGetArgs() + { + } + public static new CdnDistributionConfigGetArgs Empty => new CdnDistributionConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionDomainArgs.cs b/sdk/dotnet/Inputs/CdnDistributionDomainArgs.cs new file mode 100644 index 0000000..fa50046 --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionDomainArgs.cs @@ -0,0 +1,50 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionDomainArgs : global::Pulumi.ResourceArgs + { + [Input("errors")] + private InputList? _errors; + + /// + /// List of domain errors + /// + public InputList Errors + { + get => _errors ?? (_errors = new InputList()); + set => _errors = value; + } + + /// + /// The name of the domain + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The status of the domain + /// + [Input("status")] + public Input? Status { get; set; } + + /// + /// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + /// + [Input("type")] + public Input? Type { get; set; } + + public CdnDistributionDomainArgs() + { + } + public static new CdnDistributionDomainArgs Empty => new CdnDistributionDomainArgs(); + } +} diff --git a/sdk/dotnet/Inputs/CdnDistributionDomainGetArgs.cs b/sdk/dotnet/Inputs/CdnDistributionDomainGetArgs.cs new file mode 100644 index 0000000..fbc0c75 --- /dev/null +++ b/sdk/dotnet/Inputs/CdnDistributionDomainGetArgs.cs @@ -0,0 +1,50 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class CdnDistributionDomainGetArgs : global::Pulumi.ResourceArgs + { + [Input("errors")] + private InputList? _errors; + + /// + /// List of domain errors + /// + public InputList Errors + { + get => _errors ?? (_errors = new InputList()); + set => _errors = value; + } + + /// + /// The name of the domain + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The status of the domain + /// + [Input("status")] + public Input? Status { get; set; } + + /// + /// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + /// + [Input("type")] + public Input? Type { get; set; } + + public CdnDistributionDomainGetArgs() + { + } + public static new CdnDistributionDomainGetArgs Empty => new CdnDistributionDomainGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ImageChecksumArgs.cs b/sdk/dotnet/Inputs/ImageChecksumArgs.cs new file mode 100644 index 0000000..2cf267d --- /dev/null +++ b/sdk/dotnet/Inputs/ImageChecksumArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ImageChecksumArgs : global::Pulumi.ResourceArgs + { + /// + /// Algorithm for the checksum of the image data. + /// + [Input("algorithm")] + public Input? Algorithm { get; set; } + + /// + /// Hexdigest of the checksum of the image data. + /// + [Input("digest")] + public Input? Digest { get; set; } + + public ImageChecksumArgs() + { + } + public static new ImageChecksumArgs Empty => new ImageChecksumArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ImageChecksumGetArgs.cs b/sdk/dotnet/Inputs/ImageChecksumGetArgs.cs new file mode 100644 index 0000000..c126373 --- /dev/null +++ b/sdk/dotnet/Inputs/ImageChecksumGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ImageChecksumGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Algorithm for the checksum of the image data. + /// + [Input("algorithm")] + public Input? Algorithm { get; set; } + + /// + /// Hexdigest of the checksum of the image data. + /// + [Input("digest")] + public Input? Digest { get; set; } + + public ImageChecksumGetArgs() + { + } + public static new ImageChecksumGetArgs Empty => new ImageChecksumGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ImageConfigArgs.cs b/sdk/dotnet/Inputs/ImageConfigArgs.cs new file mode 100644 index 0000000..82368fd --- /dev/null +++ b/sdk/dotnet/Inputs/ImageConfigArgs.cs @@ -0,0 +1,98 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ImageConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// Enables the BIOS bootmenu. + /// + [Input("bootMenu")] + public Input? BootMenu { get; set; } + + /// + /// Sets CDROM bus controller type. + /// + [Input("cdromBus")] + public Input? CdromBus { get; set; } + + /// + /// Sets Disk bus controller type. + /// + [Input("diskBus")] + public Input? DiskBus { get; set; } + + /// + /// Sets virtual network interface model. + /// + [Input("nicModel")] + public Input? NicModel { get; set; } + + /// + /// Enables operating system specific optimizations. + /// + [Input("operatingSystem")] + public Input? OperatingSystem { get; set; } + + /// + /// Operating system distribution. + /// + [Input("operatingSystemDistro")] + public Input? OperatingSystemDistro { get; set; } + + /// + /// Version of the operating system. + /// + [Input("operatingSystemVersion")] + public Input? OperatingSystemVersion { get; set; } + + /// + /// Sets the device bus when the image is used as a rescue image. + /// + [Input("rescueBus")] + public Input? RescueBus { get; set; } + + /// + /// Sets the device when the image is used as a rescue image. + /// + [Input("rescueDevice")] + public Input? RescueDevice { get; set; } + + /// + /// Enables Secure Boot. + /// + [Input("secureBoot")] + public Input? SecureBoot { get; set; } + + /// + /// Enables UEFI boot. + /// + [Input("uefi")] + public Input? Uefi { get; set; } + + /// + /// Sets Graphic device model. + /// + [Input("videoModel")] + public Input? VideoModel { get; set; } + + /// + /// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + /// + [Input("virtioScsi")] + public Input? VirtioScsi { get; set; } + + public ImageConfigArgs() + { + } + public static new ImageConfigArgs Empty => new ImageConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ImageConfigGetArgs.cs b/sdk/dotnet/Inputs/ImageConfigGetArgs.cs new file mode 100644 index 0000000..1180ccd --- /dev/null +++ b/sdk/dotnet/Inputs/ImageConfigGetArgs.cs @@ -0,0 +1,98 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ImageConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Enables the BIOS bootmenu. + /// + [Input("bootMenu")] + public Input? BootMenu { get; set; } + + /// + /// Sets CDROM bus controller type. + /// + [Input("cdromBus")] + public Input? CdromBus { get; set; } + + /// + /// Sets Disk bus controller type. + /// + [Input("diskBus")] + public Input? DiskBus { get; set; } + + /// + /// Sets virtual network interface model. + /// + [Input("nicModel")] + public Input? NicModel { get; set; } + + /// + /// Enables operating system specific optimizations. + /// + [Input("operatingSystem")] + public Input? OperatingSystem { get; set; } + + /// + /// Operating system distribution. + /// + [Input("operatingSystemDistro")] + public Input? OperatingSystemDistro { get; set; } + + /// + /// Version of the operating system. + /// + [Input("operatingSystemVersion")] + public Input? OperatingSystemVersion { get; set; } + + /// + /// Sets the device bus when the image is used as a rescue image. + /// + [Input("rescueBus")] + public Input? RescueBus { get; set; } + + /// + /// Sets the device when the image is used as a rescue image. + /// + [Input("rescueDevice")] + public Input? RescueDevice { get; set; } + + /// + /// Enables Secure Boot. + /// + [Input("secureBoot")] + public Input? SecureBoot { get; set; } + + /// + /// Enables UEFI boot. + /// + [Input("uefi")] + public Input? Uefi { get; set; } + + /// + /// Sets Graphic device model. + /// + [Input("videoModel")] + public Input? VideoModel { get; set; } + + /// + /// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + /// + [Input("virtioScsi")] + public Input? VirtioScsi { get; set; } + + public ImageConfigGetArgs() + { + } + public static new ImageConfigGetArgs Empty => new ImageConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerListenerArgs.cs b/sdk/dotnet/Inputs/LoadbalancerListenerArgs.cs new file mode 100644 index 0000000..f225853 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerListenerArgs.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerListenerArgs : global::Pulumi.ResourceArgs + { + [Input("displayName")] + public Input? DisplayName { get; set; } + + /// + /// Port number where we listen for traffic. + /// + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + /// + /// Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + /// + [Input("protocol", required: true)] + public Input Protocol { get; set; } = null!; + + [Input("serverNameIndicators")] + private InputList? _serverNameIndicators; + + /// + /// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + /// + public InputList ServerNameIndicators + { + get => _serverNameIndicators ?? (_serverNameIndicators = new InputList()); + set => _serverNameIndicators = value; + } + + /// + /// Reference target pool by target pool name. + /// + [Input("targetPool", required: true)] + public Input TargetPool { get; set; } = null!; + + public LoadbalancerListenerArgs() + { + } + public static new LoadbalancerListenerArgs Empty => new LoadbalancerListenerArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerListenerGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerListenerGetArgs.cs new file mode 100644 index 0000000..82ccff9 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerListenerGetArgs.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerListenerGetArgs : global::Pulumi.ResourceArgs + { + [Input("displayName")] + public Input? DisplayName { get; set; } + + /// + /// Port number where we listen for traffic. + /// + [Input("port", required: true)] + public Input Port { get; set; } = null!; + + /// + /// Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + /// + [Input("protocol", required: true)] + public Input Protocol { get; set; } = null!; + + [Input("serverNameIndicators")] + private InputList? _serverNameIndicators; + + /// + /// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + /// + public InputList ServerNameIndicators + { + get => _serverNameIndicators ?? (_serverNameIndicators = new InputList()); + set => _serverNameIndicators = value; + } + + /// + /// Reference target pool by target pool name. + /// + [Input("targetPool", required: true)] + public Input TargetPool { get; set; } = null!; + + public LoadbalancerListenerGetArgs() + { + } + public static new LoadbalancerListenerGetArgs Empty => new LoadbalancerListenerGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorArgs.cs b/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorArgs.cs new file mode 100644 index 0000000..6cbaa33 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerListenerServerNameIndicatorArgs : global::Pulumi.ResourceArgs + { + /// + /// A domain name to match in order to pass TLS traffic to the target pool in the current listener + /// + [Input("name")] + public Input? Name { get; set; } + + public LoadbalancerListenerServerNameIndicatorArgs() + { + } + public static new LoadbalancerListenerServerNameIndicatorArgs Empty => new LoadbalancerListenerServerNameIndicatorArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorGetArgs.cs new file mode 100644 index 0000000..33b509a --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerListenerServerNameIndicatorGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerListenerServerNameIndicatorGetArgs : global::Pulumi.ResourceArgs + { + /// + /// A domain name to match in order to pass TLS traffic to the target pool in the current listener + /// + [Input("name")] + public Input? Name { get; set; } + + public LoadbalancerListenerServerNameIndicatorGetArgs() + { + } + public static new LoadbalancerListenerServerNameIndicatorGetArgs Empty => new LoadbalancerListenerServerNameIndicatorGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerNetworkArgs.cs b/sdk/dotnet/Inputs/LoadbalancerNetworkArgs.cs new file mode 100644 index 0000000..30d77a4 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerNetworkArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerNetworkArgs : global::Pulumi.ResourceArgs + { + /// + /// Openstack network ID. + /// + [Input("networkId", required: true)] + public Input NetworkId { get; set; } = null!; + + /// + /// The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + public LoadbalancerNetworkArgs() + { + } + public static new LoadbalancerNetworkArgs Empty => new LoadbalancerNetworkArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerNetworkGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerNetworkGetArgs.cs new file mode 100644 index 0000000..99ff18e --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerNetworkGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerNetworkGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Openstack network ID. + /// + [Input("networkId", required: true)] + public Input NetworkId { get; set; } = null!; + + /// + /// The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + /// + [Input("role", required: true)] + public Input Role { get; set; } = null!; + + public LoadbalancerNetworkGetArgs() + { + } + public static new LoadbalancerNetworkGetArgs Empty => new LoadbalancerNetworkGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsArgs.cs new file mode 100644 index 0000000..5e680f4 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsArgs : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// Load Balancer is accessible only from an IP address in this range. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + /// + [Input("observability")] + public Input? Observability { get; set; } + + /// + /// If true, Load Balancer is accessible only via a private network IP address. + /// + [Input("privateNetworkOnly")] + public Input? PrivateNetworkOnly { get; set; } + + public LoadbalancerOptionsArgs() + { + } + public static new LoadbalancerOptionsArgs Empty => new LoadbalancerOptionsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsGetArgs.cs new file mode 100644 index 0000000..8270390 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsGetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsGetArgs : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// Load Balancer is accessible only from an IP address in this range. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + /// + [Input("observability")] + public Input? Observability { get; set; } + + /// + /// If true, Load Balancer is accessible only via a private network IP address. + /// + [Input("privateNetworkOnly")] + public Input? PrivateNetworkOnly { get; set; } + + public LoadbalancerOptionsGetArgs() + { + } + public static new LoadbalancerOptionsGetArgs Empty => new LoadbalancerOptionsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityArgs.cs new file mode 100644 index 0000000..bc487e5 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityArgs : global::Pulumi.ResourceArgs + { + /// + /// Observability logs configuration. Not changeable after creation. + /// + [Input("logs")] + public Input? Logs { get; set; } + + /// + /// Observability metrics configuration. Not changeable after creation. + /// + [Input("metrics")] + public Input? Metrics { get; set; } + + public LoadbalancerOptionsObservabilityArgs() + { + } + public static new LoadbalancerOptionsObservabilityArgs Empty => new LoadbalancerOptionsObservabilityArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityGetArgs.cs new file mode 100644 index 0000000..542469e --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Observability logs configuration. Not changeable after creation. + /// + [Input("logs")] + public Input? Logs { get; set; } + + /// + /// Observability metrics configuration. Not changeable after creation. + /// + [Input("metrics")] + public Input? Metrics { get; set; } + + public LoadbalancerOptionsObservabilityGetArgs() + { + } + public static new LoadbalancerOptionsObservabilityGetArgs Empty => new LoadbalancerOptionsObservabilityGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsArgs.cs new file mode 100644 index 0000000..5ebce3b --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityLogsArgs : global::Pulumi.ResourceArgs + { + /// + /// Credentials reference for logs. Not changeable after creation. + /// + [Input("credentialsRef")] + public Input? CredentialsRef { get; set; } + + /// + /// Credentials reference for logs. Not changeable after creation. + /// + [Input("pushUrl")] + public Input? PushUrl { get; set; } + + public LoadbalancerOptionsObservabilityLogsArgs() + { + } + public static new LoadbalancerOptionsObservabilityLogsArgs Empty => new LoadbalancerOptionsObservabilityLogsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsGetArgs.cs new file mode 100644 index 0000000..deaab10 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityLogsGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityLogsGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Credentials reference for logs. Not changeable after creation. + /// + [Input("credentialsRef")] + public Input? CredentialsRef { get; set; } + + /// + /// Credentials reference for logs. Not changeable after creation. + /// + [Input("pushUrl")] + public Input? PushUrl { get; set; } + + public LoadbalancerOptionsObservabilityLogsGetArgs() + { + } + public static new LoadbalancerOptionsObservabilityLogsGetArgs Empty => new LoadbalancerOptionsObservabilityLogsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsArgs.cs new file mode 100644 index 0000000..53d032a --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityMetricsArgs : global::Pulumi.ResourceArgs + { + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + [Input("credentialsRef")] + public Input? CredentialsRef { get; set; } + + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + [Input("pushUrl")] + public Input? PushUrl { get; set; } + + public LoadbalancerOptionsObservabilityMetricsArgs() + { + } + public static new LoadbalancerOptionsObservabilityMetricsArgs Empty => new LoadbalancerOptionsObservabilityMetricsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsGetArgs.cs new file mode 100644 index 0000000..b74dd59 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerOptionsObservabilityMetricsGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerOptionsObservabilityMetricsGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + [Input("credentialsRef")] + public Input? CredentialsRef { get; set; } + + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + [Input("pushUrl")] + public Input? PushUrl { get; set; } + + public LoadbalancerOptionsObservabilityMetricsGetArgs() + { + } + public static new LoadbalancerOptionsObservabilityMetricsGetArgs Empty => new LoadbalancerOptionsObservabilityMetricsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckArgs.cs new file mode 100644 index 0000000..4e00f72 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckArgs.cs @@ -0,0 +1,50 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolActiveHealthCheckArgs : global::Pulumi.ResourceArgs + { + /// + /// Healthy threshold of the health checking. + /// + [Input("healthyThreshold")] + public Input? HealthyThreshold { get; set; } + + /// + /// Interval duration of health checking in seconds. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// Interval duration threshold of the health checking in seconds. + /// + [Input("intervalJitter")] + public Input? IntervalJitter { get; set; } + + /// + /// Active health checking timeout duration in seconds. + /// + [Input("timeout")] + public Input? Timeout { get; set; } + + /// + /// Unhealthy threshold of the health checking. + /// + [Input("unhealthyThreshold")] + public Input? UnhealthyThreshold { get; set; } + + public LoadbalancerTargetPoolActiveHealthCheckArgs() + { + } + public static new LoadbalancerTargetPoolActiveHealthCheckArgs Empty => new LoadbalancerTargetPoolActiveHealthCheckArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckGetArgs.cs new file mode 100644 index 0000000..3681f95 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolActiveHealthCheckGetArgs.cs @@ -0,0 +1,50 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolActiveHealthCheckGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Healthy threshold of the health checking. + /// + [Input("healthyThreshold")] + public Input? HealthyThreshold { get; set; } + + /// + /// Interval duration of health checking in seconds. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// Interval duration threshold of the health checking in seconds. + /// + [Input("intervalJitter")] + public Input? IntervalJitter { get; set; } + + /// + /// Active health checking timeout duration in seconds. + /// + [Input("timeout")] + public Input? Timeout { get; set; } + + /// + /// Unhealthy threshold of the health checking. + /// + [Input("unhealthyThreshold")] + public Input? UnhealthyThreshold { get; set; } + + public LoadbalancerTargetPoolActiveHealthCheckGetArgs() + { + } + public static new LoadbalancerTargetPoolActiveHealthCheckGetArgs Empty => new LoadbalancerTargetPoolActiveHealthCheckGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolArgs.cs new file mode 100644 index 0000000..62bda5f --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolArgs.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolArgs : global::Pulumi.ResourceArgs + { + [Input("activeHealthCheck")] + public Input? ActiveHealthCheck { get; set; } + + /// + /// Target pool name. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + /// + [Input("sessionPersistence")] + public Input? SessionPersistence { get; set; } + + /// + /// Identical port number where each target listens for traffic. + /// + [Input("targetPort", required: true)] + public Input TargetPort { get; set; } = null!; + + [Input("targets", required: true)] + private InputList? _targets; + + /// + /// List of all targets which will be used in the pool. Limited to 1000. + /// + public InputList Targets + { + get => _targets ?? (_targets = new InputList()); + set => _targets = value; + } + + public LoadbalancerTargetPoolArgs() + { + } + public static new LoadbalancerTargetPoolArgs Empty => new LoadbalancerTargetPoolArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolGetArgs.cs new file mode 100644 index 0000000..3b4f27c --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolGetArgs.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolGetArgs : global::Pulumi.ResourceArgs + { + [Input("activeHealthCheck")] + public Input? ActiveHealthCheck { get; set; } + + /// + /// Target pool name. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + /// + [Input("sessionPersistence")] + public Input? SessionPersistence { get; set; } + + /// + /// Identical port number where each target listens for traffic. + /// + [Input("targetPort", required: true)] + public Input TargetPort { get; set; } = null!; + + [Input("targets", required: true)] + private InputList? _targets; + + /// + /// List of all targets which will be used in the pool. Limited to 1000. + /// + public InputList Targets + { + get => _targets ?? (_targets = new InputList()); + set => _targets = value; + } + + public LoadbalancerTargetPoolGetArgs() + { + } + public static new LoadbalancerTargetPoolGetArgs Empty => new LoadbalancerTargetPoolGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceArgs.cs new file mode 100644 index 0000000..17d7d9a --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolSessionPersistenceArgs : global::Pulumi.ResourceArgs + { + /// + /// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + /// + [Input("useSourceIpAddress")] + public Input? UseSourceIpAddress { get; set; } + + public LoadbalancerTargetPoolSessionPersistenceArgs() + { + } + public static new LoadbalancerTargetPoolSessionPersistenceArgs Empty => new LoadbalancerTargetPoolSessionPersistenceArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceGetArgs.cs new file mode 100644 index 0000000..3fec717 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolSessionPersistenceGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolSessionPersistenceGetArgs : global::Pulumi.ResourceArgs + { + /// + /// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + /// + [Input("useSourceIpAddress")] + public Input? UseSourceIpAddress { get; set; } + + public LoadbalancerTargetPoolSessionPersistenceGetArgs() + { + } + public static new LoadbalancerTargetPoolSessionPersistenceGetArgs Empty => new LoadbalancerTargetPoolSessionPersistenceGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetArgs.cs new file mode 100644 index 0000000..a59344d --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolTargetArgs : global::Pulumi.ResourceArgs + { + /// + /// Target display name + /// + [Input("displayName", required: true)] + public Input DisplayName { get; set; } = null!; + + /// + /// Target IP + /// + [Input("ip", required: true)] + public Input Ip { get; set; } = null!; + + public LoadbalancerTargetPoolTargetArgs() + { + } + public static new LoadbalancerTargetPoolTargetArgs Empty => new LoadbalancerTargetPoolTargetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetGetArgs.cs b/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetGetArgs.cs new file mode 100644 index 0000000..e2d11d8 --- /dev/null +++ b/sdk/dotnet/Inputs/LoadbalancerTargetPoolTargetGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LoadbalancerTargetPoolTargetGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Target display name + /// + [Input("displayName", required: true)] + public Input DisplayName { get; set; } = null!; + + /// + /// Target IP + /// + [Input("ip", required: true)] + public Input Ip { get; set; } = null!; + + public LoadbalancerTargetPoolTargetGetArgs() + { + } + public static new LoadbalancerTargetPoolTargetGetArgs Empty => new LoadbalancerTargetPoolTargetGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LogmeInstanceParametersArgs.cs b/sdk/dotnet/Inputs/LogmeInstanceParametersArgs.cs new file mode 100644 index 0000000..612c823 --- /dev/null +++ b/sdk/dotnet/Inputs/LogmeInstanceParametersArgs.cs @@ -0,0 +1,138 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LogmeInstanceParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + [Input("fluentdTcp")] + public Input? FluentdTcp { get; set; } + + [Input("fluentdTls")] + public Input? FluentdTls { get; set; } + + [Input("fluentdTlsCiphers")] + public Input? FluentdTlsCiphers { get; set; } + + [Input("fluentdTlsMaxVersion")] + public Input? FluentdTlsMaxVersion { get; set; } + + [Input("fluentdTlsMinVersion")] + public Input? FluentdTlsMinVersion { get; set; } + + [Input("fluentdTlsVersion")] + public Input? FluentdTlsVersion { get; set; } + + [Input("fluentdUdp")] + public Input? FluentdUdp { get; set; } + + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + /// + [Input("ismDeletionAfter")] + public Input? IsmDeletionAfter { get; set; } + + [Input("ismJitter")] + public Input? IsmJitter { get; set; } + + /// + /// Jitter of the execution time. + /// + [Input("ismJobInterval")] + public Input? IsmJobInterval { get; set; } + + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + [Input("javaHeapspace")] + public Input? JavaHeapspace { get; set; } + + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + [Input("javaMaxmetaspace")] + public Input? JavaMaxmetaspace { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("opensearchTlsCiphers")] + private InputList? _opensearchTlsCiphers; + public InputList OpensearchTlsCiphers + { + get => _opensearchTlsCiphers ?? (_opensearchTlsCiphers = new InputList()); + set => _opensearchTlsCiphers = value; + } + + [Input("opensearchTlsProtocols")] + private InputList? _opensearchTlsProtocols; + public InputList OpensearchTlsProtocols + { + get => _opensearchTlsProtocols ?? (_opensearchTlsProtocols = new InputList()); + set => _opensearchTlsProtocols = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + public LogmeInstanceParametersArgs() + { + } + public static new LogmeInstanceParametersArgs Empty => new LogmeInstanceParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/LogmeInstanceParametersGetArgs.cs b/sdk/dotnet/Inputs/LogmeInstanceParametersGetArgs.cs new file mode 100644 index 0000000..1309d9e --- /dev/null +++ b/sdk/dotnet/Inputs/LogmeInstanceParametersGetArgs.cs @@ -0,0 +1,138 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class LogmeInstanceParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + [Input("fluentdTcp")] + public Input? FluentdTcp { get; set; } + + [Input("fluentdTls")] + public Input? FluentdTls { get; set; } + + [Input("fluentdTlsCiphers")] + public Input? FluentdTlsCiphers { get; set; } + + [Input("fluentdTlsMaxVersion")] + public Input? FluentdTlsMaxVersion { get; set; } + + [Input("fluentdTlsMinVersion")] + public Input? FluentdTlsMinVersion { get; set; } + + [Input("fluentdTlsVersion")] + public Input? FluentdTlsVersion { get; set; } + + [Input("fluentdUdp")] + public Input? FluentdUdp { get; set; } + + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + /// + [Input("ismDeletionAfter")] + public Input? IsmDeletionAfter { get; set; } + + [Input("ismJitter")] + public Input? IsmJitter { get; set; } + + /// + /// Jitter of the execution time. + /// + [Input("ismJobInterval")] + public Input? IsmJobInterval { get; set; } + + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + [Input("javaHeapspace")] + public Input? JavaHeapspace { get; set; } + + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + [Input("javaMaxmetaspace")] + public Input? JavaMaxmetaspace { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("opensearchTlsCiphers")] + private InputList? _opensearchTlsCiphers; + public InputList OpensearchTlsCiphers + { + get => _opensearchTlsCiphers ?? (_opensearchTlsCiphers = new InputList()); + set => _opensearchTlsCiphers = value; + } + + [Input("opensearchTlsProtocols")] + private InputList? _opensearchTlsProtocols; + public InputList OpensearchTlsProtocols + { + get => _opensearchTlsProtocols ?? (_opensearchTlsProtocols = new InputList()); + set => _opensearchTlsProtocols = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + public LogmeInstanceParametersGetArgs() + { + } + public static new LogmeInstanceParametersGetArgs Empty => new LogmeInstanceParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MariadbInstanceParametersArgs.cs b/sdk/dotnet/Inputs/MariadbInstanceParametersArgs.cs new file mode 100644 index 0000000..f805822 --- /dev/null +++ b/sdk/dotnet/Inputs/MariadbInstanceParametersArgs.cs @@ -0,0 +1,74 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MariadbInstanceParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + public MariadbInstanceParametersArgs() + { + } + public static new MariadbInstanceParametersArgs Empty => new MariadbInstanceParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MariadbInstanceParametersGetArgs.cs b/sdk/dotnet/Inputs/MariadbInstanceParametersGetArgs.cs new file mode 100644 index 0000000..23777eb --- /dev/null +++ b/sdk/dotnet/Inputs/MariadbInstanceParametersGetArgs.cs @@ -0,0 +1,74 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MariadbInstanceParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + public MariadbInstanceParametersGetArgs() + { + } + public static new MariadbInstanceParametersGetArgs Empty => new MariadbInstanceParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceFlavorArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceFlavorArgs.cs new file mode 100644 index 0000000..e522eda --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceFlavorArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceFlavorArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public MongodbflexInstanceFlavorArgs() + { + } + public static new MongodbflexInstanceFlavorArgs Empty => new MongodbflexInstanceFlavorArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceFlavorGetArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceFlavorGetArgs.cs new file mode 100644 index 0000000..d0437f7 --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceFlavorGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceFlavorGetArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public MongodbflexInstanceFlavorGetArgs() + { + } + public static new MongodbflexInstanceFlavorGetArgs Empty => new MongodbflexInstanceFlavorGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceOptionsArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceOptionsArgs.cs new file mode 100644 index 0000000..9c0495c --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceOptionsArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceOptionsArgs : global::Pulumi.ResourceArgs + { + /// + /// The number of days that daily backups will be retained. + /// + [Input("dailySnapshotRetentionDays")] + public Input? DailySnapshotRetentionDays { get; set; } + + /// + /// The number of months that monthly backups will be retained. + /// + [Input("monthlySnapshotRetentionMonths")] + public Input? MonthlySnapshotRetentionMonths { get; set; } + + /// + /// The number of hours back in time the point-in-time recovery feature will be able to recover. + /// + [Input("pointInTimeWindowHours", required: true)] + public Input PointInTimeWindowHours { get; set; } = null!; + + /// + /// The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + /// + [Input("snapshotRetentionDays")] + public Input? SnapshotRetentionDays { get; set; } + + /// + /// Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + /// + /// The number of weeks that weekly backups will be retained. + /// + [Input("weeklySnapshotRetentionWeeks")] + public Input? WeeklySnapshotRetentionWeeks { get; set; } + + public MongodbflexInstanceOptionsArgs() + { + } + public static new MongodbflexInstanceOptionsArgs Empty => new MongodbflexInstanceOptionsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceOptionsGetArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceOptionsGetArgs.cs new file mode 100644 index 0000000..7768874 --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceOptionsGetArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceOptionsGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The number of days that daily backups will be retained. + /// + [Input("dailySnapshotRetentionDays")] + public Input? DailySnapshotRetentionDays { get; set; } + + /// + /// The number of months that monthly backups will be retained. + /// + [Input("monthlySnapshotRetentionMonths")] + public Input? MonthlySnapshotRetentionMonths { get; set; } + + /// + /// The number of hours back in time the point-in-time recovery feature will be able to recover. + /// + [Input("pointInTimeWindowHours", required: true)] + public Input PointInTimeWindowHours { get; set; } = null!; + + /// + /// The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + /// + [Input("snapshotRetentionDays")] + public Input? SnapshotRetentionDays { get; set; } + + /// + /// Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + /// + /// The number of weeks that weekly backups will be retained. + /// + [Input("weeklySnapshotRetentionWeeks")] + public Input? WeeklySnapshotRetentionWeeks { get; set; } + + public MongodbflexInstanceOptionsGetArgs() + { + } + public static new MongodbflexInstanceOptionsGetArgs Empty => new MongodbflexInstanceOptionsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceStorageArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceStorageArgs.cs new file mode 100644 index 0000000..7164c85 --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceStorageArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceStorageArgs : global::Pulumi.ResourceArgs + { + [Input("class", required: true)] + public Input Class { get; set; } = null!; + + [Input("size", required: true)] + public Input Size { get; set; } = null!; + + public MongodbflexInstanceStorageArgs() + { + } + public static new MongodbflexInstanceStorageArgs Empty => new MongodbflexInstanceStorageArgs(); + } +} diff --git a/sdk/dotnet/Inputs/MongodbflexInstanceStorageGetArgs.cs b/sdk/dotnet/Inputs/MongodbflexInstanceStorageGetArgs.cs new file mode 100644 index 0000000..100ab1a --- /dev/null +++ b/sdk/dotnet/Inputs/MongodbflexInstanceStorageGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class MongodbflexInstanceStorageGetArgs : global::Pulumi.ResourceArgs + { + [Input("class", required: true)] + public Input Class { get; set; } = null!; + + [Input("size", required: true)] + public Input Size { get; set; } = null!; + + public MongodbflexInstanceStorageGetArgs() + { + } + public static new MongodbflexInstanceStorageGetArgs Empty => new MongodbflexInstanceStorageGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/NetworkAreaNetworkRangeArgs.cs b/sdk/dotnet/Inputs/NetworkAreaNetworkRangeArgs.cs new file mode 100644 index 0000000..2ae2b77 --- /dev/null +++ b/sdk/dotnet/Inputs/NetworkAreaNetworkRangeArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class NetworkAreaNetworkRangeArgs : global::Pulumi.ResourceArgs + { + [Input("networkRangeId")] + public Input? NetworkRangeId { get; set; } + + /// + /// Classless Inter-Domain Routing (CIDR). + /// + [Input("prefix", required: true)] + public Input Prefix { get; set; } = null!; + + public NetworkAreaNetworkRangeArgs() + { + } + public static new NetworkAreaNetworkRangeArgs Empty => new NetworkAreaNetworkRangeArgs(); + } +} diff --git a/sdk/dotnet/Inputs/NetworkAreaNetworkRangeGetArgs.cs b/sdk/dotnet/Inputs/NetworkAreaNetworkRangeGetArgs.cs new file mode 100644 index 0000000..40ca215 --- /dev/null +++ b/sdk/dotnet/Inputs/NetworkAreaNetworkRangeGetArgs.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class NetworkAreaNetworkRangeGetArgs : global::Pulumi.ResourceArgs + { + [Input("networkRangeId")] + public Input? NetworkRangeId { get; set; } + + /// + /// Classless Inter-Domain Routing (CIDR). + /// + [Input("prefix", required: true)] + public Input Prefix { get; set; } = null!; + + public NetworkAreaNetworkRangeGetArgs() + { + } + public static new NetworkAreaNetworkRangeGetArgs Empty => new NetworkAreaNetworkRangeGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleArgs.cs b/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleArgs.cs new file mode 100644 index 0000000..1ea2226 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityAlertgroupRuleArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + [Input("alert", required: true)] + public Input Alert { get; set; } = null!; + + [Input("annotations")] + private InputMap? _annotations; + + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public InputMap Annotations + { + get => _annotations ?? (_annotations = new InputMap()); + set => _annotations = value; + } + + /// + /// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + [Input("expression", required: true)] + public Input Expression { get; set; } = null!; + + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + [Input("for")] + public Input? For { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + public ObservabilityAlertgroupRuleArgs() + { + } + public static new ObservabilityAlertgroupRuleArgs Empty => new ObservabilityAlertgroupRuleArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleGetArgs.cs new file mode 100644 index 0000000..2089235 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityAlertgroupRuleGetArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityAlertgroupRuleGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + [Input("alert", required: true)] + public Input Alert { get; set; } = null!; + + [Input("annotations")] + private InputMap? _annotations; + + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public InputMap Annotations + { + get => _annotations ?? (_annotations = new InputMap()); + set => _annotations = value; + } + + /// + /// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + [Input("expression", required: true)] + public Input Expression { get; set; } = null!; + + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + [Input("for")] + public Input? For { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + public ObservabilityAlertgroupRuleGetArgs() + { + } + public static new ObservabilityAlertgroupRuleGetArgs Empty => new ObservabilityAlertgroupRuleGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigArgs.cs new file mode 100644 index 0000000..9d2bf3d --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// Global configuration for the alerts. + /// + [Input("global")] + public Input? Global { get; set; } + + [Input("receivers", required: true)] + private InputList? _receivers; + + /// + /// List of alert receivers. + /// + public InputList Receivers + { + get => _receivers ?? (_receivers = new InputList()); + set => _receivers = value; + } + + /// + /// Route configuration for the alerts. + /// + [Input("route", required: true)] + public Input Route { get; set; } = null!; + + public ObservabilityInstanceAlertConfigArgs() + { + } + public static new ObservabilityInstanceAlertConfigArgs Empty => new ObservabilityInstanceAlertConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGetArgs.cs new file mode 100644 index 0000000..95bc805 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Global configuration for the alerts. + /// + [Input("global")] + public Input? Global { get; set; } + + [Input("receivers", required: true)] + private InputList? _receivers; + + /// + /// List of alert receivers. + /// + public InputList Receivers + { + get => _receivers ?? (_receivers = new InputList()); + set => _receivers = value; + } + + /// + /// Route configuration for the alerts. + /// + [Input("route", required: true)] + public Input Route { get; set; } = null!; + + public ObservabilityInstanceAlertConfigGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigGetArgs Empty => new ObservabilityInstanceAlertConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalArgs.cs new file mode 100644 index 0000000..0420e10 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalArgs.cs @@ -0,0 +1,88 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigGlobalArgs : global::Pulumi.ResourceArgs + { + [Input("opsgenieApiKey")] + private Input? _opsgenieApiKey; + + /// + /// The API key for OpsGenie. + /// + public Input? OpsgenieApiKey + { + get => _opsgenieApiKey; + set + { + var emptySecret = Output.CreateSecret(0); + _opsgenieApiKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + [Input("opsgenieApiUrl")] + public Input? OpsgenieApiUrl { get; set; } + + /// + /// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + /// + [Input("resolveTimeout")] + public Input? ResolveTimeout { get; set; } + + /// + /// SMTP authentication information. Must be a valid email address + /// + [Input("smtpAuthIdentity")] + public Input? SmtpAuthIdentity { get; set; } + + [Input("smtpAuthPassword")] + private Input? _smtpAuthPassword; + + /// + /// SMTP Auth using LOGIN and PLAIN. + /// + public Input? SmtpAuthPassword + { + get => _smtpAuthPassword; + set + { + var emptySecret = Output.CreateSecret(0); + _smtpAuthPassword = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + /// + [Input("smtpAuthUsername")] + public Input? SmtpAuthUsername { get; set; } + + /// + /// The default SMTP From header field. Must be a valid email address + /// + [Input("smtpFrom")] + public Input? SmtpFrom { get; set; } + + /// + /// The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + /// + [Input("smtpSmartHost")] + public Input? SmtpSmartHost { get; set; } + + public ObservabilityInstanceAlertConfigGlobalArgs() + { + } + public static new ObservabilityInstanceAlertConfigGlobalArgs Empty => new ObservabilityInstanceAlertConfigGlobalArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalGetArgs.cs new file mode 100644 index 0000000..e87c98e --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigGlobalGetArgs.cs @@ -0,0 +1,88 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigGlobalGetArgs : global::Pulumi.ResourceArgs + { + [Input("opsgenieApiKey")] + private Input? _opsgenieApiKey; + + /// + /// The API key for OpsGenie. + /// + public Input? OpsgenieApiKey + { + get => _opsgenieApiKey; + set + { + var emptySecret = Output.CreateSecret(0); + _opsgenieApiKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + [Input("opsgenieApiUrl")] + public Input? OpsgenieApiUrl { get; set; } + + /// + /// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + /// + [Input("resolveTimeout")] + public Input? ResolveTimeout { get; set; } + + /// + /// SMTP authentication information. Must be a valid email address + /// + [Input("smtpAuthIdentity")] + public Input? SmtpAuthIdentity { get; set; } + + [Input("smtpAuthPassword")] + private Input? _smtpAuthPassword; + + /// + /// SMTP Auth using LOGIN and PLAIN. + /// + public Input? SmtpAuthPassword + { + get => _smtpAuthPassword; + set + { + var emptySecret = Output.CreateSecret(0); + _smtpAuthPassword = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + /// + [Input("smtpAuthUsername")] + public Input? SmtpAuthUsername { get; set; } + + /// + /// The default SMTP From header field. Must be a valid email address + /// + [Input("smtpFrom")] + public Input? SmtpFrom { get; set; } + + /// + /// The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + /// + [Input("smtpSmartHost")] + public Input? SmtpSmartHost { get; set; } + + public ObservabilityInstanceAlertConfigGlobalGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigGlobalGetArgs Empty => new ObservabilityInstanceAlertConfigGlobalGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverArgs.cs new file mode 100644 index 0000000..c910bb6 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverArgs : global::Pulumi.ResourceArgs + { + [Input("emailConfigs")] + private InputList? _emailConfigs; + + /// + /// List of email configurations. + /// + public InputList EmailConfigs + { + get => _emailConfigs ?? (_emailConfigs = new InputList()); + set => _emailConfigs = value; + } + + /// + /// Name of the receiver. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + [Input("opsgenieConfigs")] + private InputList? _opsgenieConfigs; + + /// + /// List of OpsGenie configurations. + /// + public InputList OpsgenieConfigs + { + get => _opsgenieConfigs ?? (_opsgenieConfigs = new InputList()); + set => _opsgenieConfigs = value; + } + + [Input("webhooksConfigs")] + private InputList? _webhooksConfigs; + + /// + /// List of Webhooks configurations. + /// + public InputList WebhooksConfigs + { + get => _webhooksConfigs ?? (_webhooksConfigs = new InputList()); + set => _webhooksConfigs = value; + } + + public ObservabilityInstanceAlertConfigReceiverArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverArgs Empty => new ObservabilityInstanceAlertConfigReceiverArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigArgs.cs new file mode 100644 index 0000000..aad06c4 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverEmailConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// SMTP authentication information. Must be a valid email address + /// + [Input("authIdentity")] + public Input? AuthIdentity { get; set; } + + /// + /// SMTP authentication password. + /// + [Input("authPassword")] + public Input? AuthPassword { get; set; } + + /// + /// SMTP authentication username. + /// + [Input("authUsername")] + public Input? AuthUsername { get; set; } + + /// + /// The sender email address. Must be a valid email address + /// + [Input("from")] + public Input? From { get; set; } + + /// + /// The SMTP host through which emails are sent. + /// + [Input("smartHost")] + public Input? SmartHost { get; set; } + + /// + /// The email address to send notifications to. Must be a valid email address + /// + [Input("to")] + public Input? To { get; set; } + + public ObservabilityInstanceAlertConfigReceiverEmailConfigArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverEmailConfigArgs Empty => new ObservabilityInstanceAlertConfigReceiverEmailConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs.cs new file mode 100644 index 0000000..3ed9795 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// SMTP authentication information. Must be a valid email address + /// + [Input("authIdentity")] + public Input? AuthIdentity { get; set; } + + /// + /// SMTP authentication password. + /// + [Input("authPassword")] + public Input? AuthPassword { get; set; } + + /// + /// SMTP authentication username. + /// + [Input("authUsername")] + public Input? AuthUsername { get; set; } + + /// + /// The sender email address. Must be a valid email address + /// + [Input("from")] + public Input? From { get; set; } + + /// + /// The SMTP host through which emails are sent. + /// + [Input("smartHost")] + public Input? SmartHost { get; set; } + + /// + /// The email address to send notifications to. Must be a valid email address + /// + [Input("to")] + public Input? To { get; set; } + + public ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs Empty => new ObservabilityInstanceAlertConfigReceiverEmailConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverGetArgs.cs new file mode 100644 index 0000000..20669e0 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverGetArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverGetArgs : global::Pulumi.ResourceArgs + { + [Input("emailConfigs")] + private InputList? _emailConfigs; + + /// + /// List of email configurations. + /// + public InputList EmailConfigs + { + get => _emailConfigs ?? (_emailConfigs = new InputList()); + set => _emailConfigs = value; + } + + /// + /// Name of the receiver. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + [Input("opsgenieConfigs")] + private InputList? _opsgenieConfigs; + + /// + /// List of OpsGenie configurations. + /// + public InputList OpsgenieConfigs + { + get => _opsgenieConfigs ?? (_opsgenieConfigs = new InputList()); + set => _opsgenieConfigs = value; + } + + [Input("webhooksConfigs")] + private InputList? _webhooksConfigs; + + /// + /// List of Webhooks configurations. + /// + public InputList WebhooksConfigs + { + get => _webhooksConfigs ?? (_webhooksConfigs = new InputList()); + set => _webhooksConfigs = value; + } + + public ObservabilityInstanceAlertConfigReceiverGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverGetArgs Empty => new ObservabilityInstanceAlertConfigReceiverGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs.cs new file mode 100644 index 0000000..3bab69e --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// The API key for OpsGenie. + /// + [Input("apiKey")] + public Input? ApiKey { get; set; } + + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + [Input("apiUrl")] + public Input? ApiUrl { get; set; } + + /// + /// Comma separated list of tags attached to the notifications. + /// + [Input("tags")] + public Input? Tags { get; set; } + + public ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs Empty => new ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs.cs new file mode 100644 index 0000000..610d3d0 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The API key for OpsGenie. + /// + [Input("apiKey")] + public Input? ApiKey { get; set; } + + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + [Input("apiUrl")] + public Input? ApiUrl { get; set; } + + /// + /// Comma separated list of tags attached to the notifications. + /// + [Input("tags")] + public Input? Tags { get; set; } + + public ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs Empty => new ObservabilityInstanceAlertConfigReceiverOpsgenieConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs.cs new file mode 100644 index 0000000..ec402b5 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs : global::Pulumi.ResourceArgs + { + /// + /// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + /// + [Input("msTeams")] + public Input? MsTeams { get; set; } + + /// + /// The endpoint to send HTTP POST requests to. Must be a valid URL + /// + [Input("url")] + public Input? Url { get; set; } + + public ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs Empty => new ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs.cs new file mode 100644 index 0000000..c86e771 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + /// + [Input("msTeams")] + public Input? MsTeams { get; set; } + + /// + /// The endpoint to send HTTP POST requests to. Must be a valid URL + /// + [Input("url")] + public Input? Url { get; set; } + + public ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs Empty => new ObservabilityInstanceAlertConfigReceiverWebhooksConfigGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteArgs.cs new file mode 100644 index 0000000..4cf83e4 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteArgs.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigRouteArgs : global::Pulumi.ResourceArgs + { + [Input("groupBies")] + private InputList? _groupBies; + + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public InputList GroupBies + { + get => _groupBies ?? (_groupBies = new InputList()); + set => _groupBies = value; + } + + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + [Input("groupInterval")] + public Input? GroupInterval { get; set; } + + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + [Input("groupWait")] + public Input? GroupWait { get; set; } + + [Input("match")] + private InputMap? _match; + + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public InputMap Match + { + get => _match ?? (_match = new InputMap()); + set => _match = value; + } + + [Input("matchRegex")] + private InputMap? _matchRegex; + + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public InputMap MatchRegex + { + get => _matchRegex ?? (_matchRegex = new InputMap()); + set => _matchRegex = value; + } + + /// + /// The name of the receiver to route the alerts to. + /// + [Input("receiver", required: true)] + public Input Receiver { get; set; } = null!; + + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + [Input("repeatInterval")] + public Input? RepeatInterval { get; set; } + + [Input("routes")] + private InputList? _routes; + + /// + /// List of child routes. + /// + public InputList Routes + { + get => _routes ?? (_routes = new InputList()); + set => _routes = value; + } + + public ObservabilityInstanceAlertConfigRouteArgs() + { + } + public static new ObservabilityInstanceAlertConfigRouteArgs Empty => new ObservabilityInstanceAlertConfigRouteArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteGetArgs.cs new file mode 100644 index 0000000..a998b63 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteGetArgs.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigRouteGetArgs : global::Pulumi.ResourceArgs + { + [Input("groupBies")] + private InputList? _groupBies; + + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public InputList GroupBies + { + get => _groupBies ?? (_groupBies = new InputList()); + set => _groupBies = value; + } + + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + [Input("groupInterval")] + public Input? GroupInterval { get; set; } + + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + [Input("groupWait")] + public Input? GroupWait { get; set; } + + [Input("match")] + private InputMap? _match; + + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public InputMap Match + { + get => _match ?? (_match = new InputMap()); + set => _match = value; + } + + [Input("matchRegex")] + private InputMap? _matchRegex; + + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public InputMap MatchRegex + { + get => _matchRegex ?? (_matchRegex = new InputMap()); + set => _matchRegex = value; + } + + /// + /// The name of the receiver to route the alerts to. + /// + [Input("receiver", required: true)] + public Input Receiver { get; set; } = null!; + + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + [Input("repeatInterval")] + public Input? RepeatInterval { get; set; } + + [Input("routes")] + private InputList? _routes; + + /// + /// List of child routes. + /// + public InputList Routes + { + get => _routes ?? (_routes = new InputList()); + set => _routes = value; + } + + public ObservabilityInstanceAlertConfigRouteGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigRouteGetArgs Empty => new ObservabilityInstanceAlertConfigRouteGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteArgs.cs new file mode 100644 index 0000000..be57f08 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteArgs.cs @@ -0,0 +1,80 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigRouteRouteArgs : global::Pulumi.ResourceArgs + { + [Input("groupBies")] + private InputList? _groupBies; + + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public InputList GroupBies + { + get => _groupBies ?? (_groupBies = new InputList()); + set => _groupBies = value; + } + + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + [Input("groupInterval")] + public Input? GroupInterval { get; set; } + + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + [Input("groupWait")] + public Input? GroupWait { get; set; } + + [Input("match")] + private InputMap? _match; + + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public InputMap Match + { + get => _match ?? (_match = new InputMap()); + set => _match = value; + } + + [Input("matchRegex")] + private InputMap? _matchRegex; + + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public InputMap MatchRegex + { + get => _matchRegex ?? (_matchRegex = new InputMap()); + set => _matchRegex = value; + } + + /// + /// The name of the receiver to route the alerts to. + /// + [Input("receiver", required: true)] + public Input Receiver { get; set; } = null!; + + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + [Input("repeatInterval")] + public Input? RepeatInterval { get; set; } + + public ObservabilityInstanceAlertConfigRouteRouteArgs() + { + } + public static new ObservabilityInstanceAlertConfigRouteRouteArgs Empty => new ObservabilityInstanceAlertConfigRouteRouteArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteGetArgs.cs new file mode 100644 index 0000000..f49a956 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityInstanceAlertConfigRouteRouteGetArgs.cs @@ -0,0 +1,80 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityInstanceAlertConfigRouteRouteGetArgs : global::Pulumi.ResourceArgs + { + [Input("groupBies")] + private InputList? _groupBies; + + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public InputList GroupBies + { + get => _groupBies ?? (_groupBies = new InputList()); + set => _groupBies = value; + } + + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + [Input("groupInterval")] + public Input? GroupInterval { get; set; } + + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + [Input("groupWait")] + public Input? GroupWait { get; set; } + + [Input("match")] + private InputMap? _match; + + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public InputMap Match + { + get => _match ?? (_match = new InputMap()); + set => _match = value; + } + + [Input("matchRegex")] + private InputMap? _matchRegex; + + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public InputMap MatchRegex + { + get => _matchRegex ?? (_matchRegex = new InputMap()); + set => _matchRegex = value; + } + + /// + /// The name of the receiver to route the alerts to. + /// + [Input("receiver", required: true)] + public Input Receiver { get; set; } = null!; + + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + [Input("repeatInterval")] + public Input? RepeatInterval { get; set; } + + public ObservabilityInstanceAlertConfigRouteRouteGetArgs() + { + } + public static new ObservabilityInstanceAlertConfigRouteRouteGetArgs Empty => new ObservabilityInstanceAlertConfigRouteRouteGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleArgs.cs b/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleArgs.cs new file mode 100644 index 0000000..66de6a5 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityLogalertgroupRuleArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + [Input("alert", required: true)] + public Input Alert { get; set; } = null!; + + [Input("annotations")] + private InputMap? _annotations; + + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public InputMap Annotations + { + get => _annotations ?? (_annotations = new InputMap()); + set => _annotations = value; + } + + /// + /// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + [Input("expression", required: true)] + public Input Expression { get; set; } = null!; + + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + [Input("for")] + public Input? For { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + public ObservabilityLogalertgroupRuleArgs() + { + } + public static new ObservabilityLogalertgroupRuleArgs Empty => new ObservabilityLogalertgroupRuleArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleGetArgs.cs new file mode 100644 index 0000000..64c40fe --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityLogalertgroupRuleGetArgs.cs @@ -0,0 +1,62 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityLogalertgroupRuleGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + [Input("alert", required: true)] + public Input Alert { get; set; } = null!; + + [Input("annotations")] + private InputMap? _annotations; + + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public InputMap Annotations + { + get => _annotations ?? (_annotations = new InputMap()); + set => _annotations = value; + } + + /// + /// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + [Input("expression", required: true)] + public Input Expression { get; set; } = null!; + + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + [Input("for")] + public Input? For { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + public ObservabilityLogalertgroupRuleGetArgs() + { + } + public static new ObservabilityLogalertgroupRuleGetArgs Empty => new ObservabilityLogalertgroupRuleGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthArgs.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthArgs.cs new file mode 100644 index 0000000..e2442f3 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthArgs.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigBasicAuthArgs : global::Pulumi.ResourceArgs + { + [Input("password", required: true)] + private Input? _password; + + /// + /// Specifies basic auth password. + /// + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// Specifies basic auth username. + /// + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public ObservabilityScrapeconfigBasicAuthArgs() + { + } + public static new ObservabilityScrapeconfigBasicAuthArgs Empty => new ObservabilityScrapeconfigBasicAuthArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthGetArgs.cs new file mode 100644 index 0000000..1235281 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigBasicAuthGetArgs.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigBasicAuthGetArgs : global::Pulumi.ResourceArgs + { + [Input("password", required: true)] + private Input? _password; + + /// + /// Specifies basic auth password. + /// + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// Specifies basic auth username. + /// + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public ObservabilityScrapeconfigBasicAuthGetArgs() + { + } + public static new ObservabilityScrapeconfigBasicAuthGetArgs Empty => new ObservabilityScrapeconfigBasicAuthGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2Args.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2Args.cs new file mode 100644 index 0000000..5268193 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2Args.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigSaml2Args : global::Pulumi.ResourceArgs + { + /// + /// Specifies if URL parameters are enabled. Defaults to `true` + /// + [Input("enableUrlParameters")] + public Input? EnableUrlParameters { get; set; } + + public ObservabilityScrapeconfigSaml2Args() + { + } + public static new ObservabilityScrapeconfigSaml2Args Empty => new ObservabilityScrapeconfigSaml2Args(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2GetArgs.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2GetArgs.cs new file mode 100644 index 0000000..bdb4479 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigSaml2GetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigSaml2GetArgs : global::Pulumi.ResourceArgs + { + /// + /// Specifies if URL parameters are enabled. Defaults to `true` + /// + [Input("enableUrlParameters")] + public Input? EnableUrlParameters { get; set; } + + public ObservabilityScrapeconfigSaml2GetArgs() + { + } + public static new ObservabilityScrapeconfigSaml2GetArgs Empty => new ObservabilityScrapeconfigSaml2GetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetArgs.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetArgs.cs new file mode 100644 index 0000000..c64f906 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigTargetArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Specifies labels. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + [Input("urls", required: true)] + private InputList? _urls; + + /// + /// Specifies target URLs. + /// + public InputList Urls + { + get => _urls ?? (_urls = new InputList()); + set => _urls = value; + } + + public ObservabilityScrapeconfigTargetArgs() + { + } + public static new ObservabilityScrapeconfigTargetArgs Empty => new ObservabilityScrapeconfigTargetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetGetArgs.cs b/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetGetArgs.cs new file mode 100644 index 0000000..91372b8 --- /dev/null +++ b/sdk/dotnet/Inputs/ObservabilityScrapeconfigTargetGetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ObservabilityScrapeconfigTargetGetArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Specifies labels. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + [Input("urls", required: true)] + private InputList? _urls; + + /// + /// Specifies target URLs. + /// + public InputList Urls + { + get => _urls ?? (_urls = new InputList()); + set => _urls = value; + } + + public ObservabilityScrapeconfigTargetGetArgs() + { + } + public static new ObservabilityScrapeconfigTargetGetArgs Empty => new ObservabilityScrapeconfigTargetGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/OpensearchInstanceParametersArgs.cs b/sdk/dotnet/Inputs/OpensearchInstanceParametersArgs.cs new file mode 100644 index 0000000..b2bf0e1 --- /dev/null +++ b/sdk/dotnet/Inputs/OpensearchInstanceParametersArgs.cs @@ -0,0 +1,122 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class OpensearchInstanceParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The garbage collector to use for OpenSearch. + /// + [Input("javaGarbageCollector")] + public Input? JavaGarbageCollector { get; set; } + + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + [Input("javaHeapspace")] + public Input? JavaHeapspace { get; set; } + + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + [Input("javaMaxmetaspace")] + public Input? JavaMaxmetaspace { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("plugins")] + private InputList? _plugins; + + /// + /// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + /// + public InputList Plugins + { + get => _plugins ?? (_plugins = new InputList()); + set => _plugins = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// The TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public OpensearchInstanceParametersArgs() + { + } + public static new OpensearchInstanceParametersArgs Empty => new OpensearchInstanceParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/OpensearchInstanceParametersGetArgs.cs b/sdk/dotnet/Inputs/OpensearchInstanceParametersGetArgs.cs new file mode 100644 index 0000000..697c104 --- /dev/null +++ b/sdk/dotnet/Inputs/OpensearchInstanceParametersGetArgs.cs @@ -0,0 +1,122 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class OpensearchInstanceParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The garbage collector to use for OpenSearch. + /// + [Input("javaGarbageCollector")] + public Input? JavaGarbageCollector { get; set; } + + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + [Input("javaHeapspace")] + public Input? JavaHeapspace { get; set; } + + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + [Input("javaMaxmetaspace")] + public Input? JavaMaxmetaspace { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("plugins")] + private InputList? _plugins; + + /// + /// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + /// + public InputList Plugins + { + get => _plugins ?? (_plugins = new InputList()); + set => _plugins = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// The TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public OpensearchInstanceParametersGetArgs() + { + } + public static new OpensearchInstanceParametersGetArgs Empty => new OpensearchInstanceParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/PostgresflexInstanceFlavorArgs.cs b/sdk/dotnet/Inputs/PostgresflexInstanceFlavorArgs.cs new file mode 100644 index 0000000..d766360 --- /dev/null +++ b/sdk/dotnet/Inputs/PostgresflexInstanceFlavorArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class PostgresflexInstanceFlavorArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public PostgresflexInstanceFlavorArgs() + { + } + public static new PostgresflexInstanceFlavorArgs Empty => new PostgresflexInstanceFlavorArgs(); + } +} diff --git a/sdk/dotnet/Inputs/PostgresflexInstanceFlavorGetArgs.cs b/sdk/dotnet/Inputs/PostgresflexInstanceFlavorGetArgs.cs new file mode 100644 index 0000000..fbf65ec --- /dev/null +++ b/sdk/dotnet/Inputs/PostgresflexInstanceFlavorGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class PostgresflexInstanceFlavorGetArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public PostgresflexInstanceFlavorGetArgs() + { + } + public static new PostgresflexInstanceFlavorGetArgs Empty => new PostgresflexInstanceFlavorGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/PostgresflexInstanceStorageArgs.cs b/sdk/dotnet/Inputs/PostgresflexInstanceStorageArgs.cs new file mode 100644 index 0000000..9e74139 --- /dev/null +++ b/sdk/dotnet/Inputs/PostgresflexInstanceStorageArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class PostgresflexInstanceStorageArgs : global::Pulumi.ResourceArgs + { + [Input("class", required: true)] + public Input Class { get; set; } = null!; + + [Input("size", required: true)] + public Input Size { get; set; } = null!; + + public PostgresflexInstanceStorageArgs() + { + } + public static new PostgresflexInstanceStorageArgs Empty => new PostgresflexInstanceStorageArgs(); + } +} diff --git a/sdk/dotnet/Inputs/PostgresflexInstanceStorageGetArgs.cs b/sdk/dotnet/Inputs/PostgresflexInstanceStorageGetArgs.cs new file mode 100644 index 0000000..1a1f9cd --- /dev/null +++ b/sdk/dotnet/Inputs/PostgresflexInstanceStorageGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class PostgresflexInstanceStorageGetArgs : global::Pulumi.ResourceArgs + { + [Input("class", required: true)] + public Input Class { get; set; } = null!; + + [Input("size", required: true)] + public Input Size { get; set; } = null!; + + public PostgresflexInstanceStorageGetArgs() + { + } + public static new PostgresflexInstanceStorageGetArgs Empty => new PostgresflexInstanceStorageGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/RabbitmqInstanceParametersArgs.cs b/sdk/dotnet/Inputs/RabbitmqInstanceParametersArgs.cs new file mode 100644 index 0000000..e75c926 --- /dev/null +++ b/sdk/dotnet/Inputs/RabbitmqInstanceParametersArgs.cs @@ -0,0 +1,122 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class RabbitmqInstanceParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// The timeout in milliseconds for the consumer. + /// + [Input("consumerTimeout")] + public Input? ConsumerTimeout { get; set; } + + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("plugins")] + private InputList? _plugins; + + /// + /// List of plugins to install. Must be a supported plugin name. + /// + public InputList Plugins + { + get => _plugins ?? (_plugins = new InputList()); + set => _plugins = value; + } + + [Input("roles")] + private InputList? _roles; + + /// + /// List of roles to assign to the instance. + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public RabbitmqInstanceParametersArgs() + { + } + public static new RabbitmqInstanceParametersArgs Empty => new RabbitmqInstanceParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/RabbitmqInstanceParametersGetArgs.cs b/sdk/dotnet/Inputs/RabbitmqInstanceParametersGetArgs.cs new file mode 100644 index 0000000..e01404c --- /dev/null +++ b/sdk/dotnet/Inputs/RabbitmqInstanceParametersGetArgs.cs @@ -0,0 +1,122 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class RabbitmqInstanceParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The timeout in milliseconds for the consumer. + /// + [Input("consumerTimeout")] + public Input? ConsumerTimeout { get; set; } + + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + [Input("plugins")] + private InputList? _plugins; + + /// + /// List of plugins to install. Must be a supported plugin name. + /// + public InputList Plugins + { + get => _plugins ?? (_plugins = new InputList()); + set => _plugins = value; + } + + [Input("roles")] + private InputList? _roles; + + /// + /// List of roles to assign to the instance. + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public RabbitmqInstanceParametersGetArgs() + { + } + public static new RabbitmqInstanceParametersGetArgs Empty => new RabbitmqInstanceParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/RedisInstanceParametersArgs.cs b/sdk/dotnet/Inputs/RedisInstanceParametersArgs.cs new file mode 100644 index 0000000..a12cf3f --- /dev/null +++ b/sdk/dotnet/Inputs/RedisInstanceParametersArgs.cs @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class RedisInstanceParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// The number of milliseconds after which the instance is considered down. + /// + [Input("downAfterMilliseconds")] + public Input? DownAfterMilliseconds { get; set; } + + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// The failover timeout in milliseconds. + /// + [Input("failoverTimeout")] + public Input? FailoverTimeout { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The lazy eviction enablement (yes or no). + /// + [Input("lazyfreeLazyEviction")] + public Input? LazyfreeLazyEviction { get; set; } + + /// + /// The lazy expire enablement (yes or no). + /// + [Input("lazyfreeLazyExpire")] + public Input? LazyfreeLazyExpire { get; set; } + + /// + /// The Lua time limit. + /// + [Input("luaTimeLimit")] + public Input? LuaTimeLimit { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The maximum number of clients. + /// + [Input("maxclients")] + public Input? Maxclients { get; set; } + + /// + /// The policy to handle the maximum memory (volatile-lru, noeviction, etc). + /// + [Input("maxmemoryPolicy")] + public Input? MaxmemoryPolicy { get; set; } + + /// + /// The maximum memory samples. + /// + [Input("maxmemorySamples")] + public Input? MaxmemorySamples { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The minimum replicas maximum lag. + /// + [Input("minReplicasMaxLag")] + public Input? MinReplicasMaxLag { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + /// + /// The notify keyspace events. + /// + [Input("notifyKeyspaceEvents")] + public Input? NotifyKeyspaceEvents { get; set; } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + /// + /// The snapshot configuration. + /// + [Input("snapshot")] + public Input? Snapshot { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// TLS cipher suites to use. + /// + [Input("tlsCiphersuites")] + public Input? TlsCiphersuites { get; set; } + + /// + /// TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public RedisInstanceParametersArgs() + { + } + public static new RedisInstanceParametersArgs Empty => new RedisInstanceParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/RedisInstanceParametersGetArgs.cs b/sdk/dotnet/Inputs/RedisInstanceParametersGetArgs.cs new file mode 100644 index 0000000..813c942 --- /dev/null +++ b/sdk/dotnet/Inputs/RedisInstanceParametersGetArgs.cs @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class RedisInstanceParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The number of milliseconds after which the instance is considered down. + /// + [Input("downAfterMilliseconds")] + public Input? DownAfterMilliseconds { get; set; } + + /// + /// Enable monitoring. + /// + [Input("enableMonitoring")] + public Input? EnableMonitoring { get; set; } + + /// + /// The failover timeout in milliseconds. + /// + [Input("failoverTimeout")] + public Input? FailoverTimeout { get; set; } + + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + [Input("graphite")] + public Input? Graphite { get; set; } + + /// + /// The lazy eviction enablement (yes or no). + /// + [Input("lazyfreeLazyEviction")] + public Input? LazyfreeLazyEviction { get; set; } + + /// + /// The lazy expire enablement (yes or no). + /// + [Input("lazyfreeLazyExpire")] + public Input? LazyfreeLazyExpire { get; set; } + + /// + /// The Lua time limit. + /// + [Input("luaTimeLimit")] + public Input? LuaTimeLimit { get; set; } + + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + [Input("maxDiskThreshold")] + public Input? MaxDiskThreshold { get; set; } + + /// + /// The maximum number of clients. + /// + [Input("maxclients")] + public Input? Maxclients { get; set; } + + /// + /// The policy to handle the maximum memory (volatile-lru, noeviction, etc). + /// + [Input("maxmemoryPolicy")] + public Input? MaxmemoryPolicy { get; set; } + + /// + /// The maximum memory samples. + /// + [Input("maxmemorySamples")] + public Input? MaxmemorySamples { get; set; } + + /// + /// The frequency in seconds at which metrics are emitted. + /// + [Input("metricsFrequency")] + public Input? MetricsFrequency { get; set; } + + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + [Input("metricsPrefix")] + public Input? MetricsPrefix { get; set; } + + /// + /// The minimum replicas maximum lag. + /// + [Input("minReplicasMaxLag")] + public Input? MinReplicasMaxLag { get; set; } + + /// + /// The ID of the STACKIT monitoring instance. + /// + [Input("monitoringInstanceId")] + public Input? MonitoringInstanceId { get; set; } + + /// + /// The notify keyspace events. + /// + [Input("notifyKeyspaceEvents")] + public Input? NotifyKeyspaceEvents { get; set; } + + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + [Input("sgwAcl")] + public Input? SgwAcl { get; set; } + + /// + /// The snapshot configuration. + /// + [Input("snapshot")] + public Input? Snapshot { get; set; } + + [Input("syslogs")] + private InputList? _syslogs; + + /// + /// List of syslog servers to send logs to. + /// + public InputList Syslogs + { + get => _syslogs ?? (_syslogs = new InputList()); + set => _syslogs = value; + } + + [Input("tlsCiphers")] + private InputList? _tlsCiphers; + + /// + /// List of TLS ciphers to use. + /// + public InputList TlsCiphers + { + get => _tlsCiphers ?? (_tlsCiphers = new InputList()); + set => _tlsCiphers = value; + } + + /// + /// TLS cipher suites to use. + /// + [Input("tlsCiphersuites")] + public Input? TlsCiphersuites { get; set; } + + /// + /// TLS protocol to use. + /// + [Input("tlsProtocols")] + public Input? TlsProtocols { get; set; } + + public RedisInstanceParametersGetArgs() + { + } + public static new RedisInstanceParametersGetArgs Empty => new RedisInstanceParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersArgs.cs new file mode 100644 index 0000000..14b436f --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRuleIcmpParametersArgs : global::Pulumi.ResourceArgs + { + /// + /// ICMP code. Can be set if the protocol is ICMP. + /// + [Input("code", required: true)] + public Input Code { get; set; } = null!; + + /// + /// ICMP type. Can be set if the protocol is ICMP. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public SecurityGroupRuleIcmpParametersArgs() + { + } + public static new SecurityGroupRuleIcmpParametersArgs Empty => new SecurityGroupRuleIcmpParametersArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersGetArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersGetArgs.cs new file mode 100644 index 0000000..dc9a3d9 --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRuleIcmpParametersGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRuleIcmpParametersGetArgs : global::Pulumi.ResourceArgs + { + /// + /// ICMP code. Can be set if the protocol is ICMP. + /// + [Input("code", required: true)] + public Input Code { get; set; } = null!; + + /// + /// ICMP type. Can be set if the protocol is ICMP. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public SecurityGroupRuleIcmpParametersGetArgs() + { + } + public static new SecurityGroupRuleIcmpParametersGetArgs Empty => new SecurityGroupRuleIcmpParametersGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRulePortRangeArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRulePortRangeArgs.cs new file mode 100644 index 0000000..4739c7d --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRulePortRangeArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRulePortRangeArgs : global::Pulumi.ResourceArgs + { + /// + /// The maximum port number. Should be greater or equal to the minimum. + /// + [Input("max", required: true)] + public Input Max { get; set; } = null!; + + /// + /// The minimum port number. Should be less or equal to the maximum. + /// + [Input("min", required: true)] + public Input Min { get; set; } = null!; + + public SecurityGroupRulePortRangeArgs() + { + } + public static new SecurityGroupRulePortRangeArgs Empty => new SecurityGroupRulePortRangeArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRulePortRangeGetArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRulePortRangeGetArgs.cs new file mode 100644 index 0000000..a418b87 --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRulePortRangeGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRulePortRangeGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The maximum port number. Should be greater or equal to the minimum. + /// + [Input("max", required: true)] + public Input Max { get; set; } = null!; + + /// + /// The minimum port number. Should be less or equal to the maximum. + /// + [Input("min", required: true)] + public Input Min { get; set; } = null!; + + public SecurityGroupRulePortRangeGetArgs() + { + } + public static new SecurityGroupRulePortRangeGetArgs Empty => new SecurityGroupRulePortRangeGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRuleProtocolArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRuleProtocolArgs.cs new file mode 100644 index 0000000..e2dd53f --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRuleProtocolArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRuleProtocolArgs : global::Pulumi.ResourceArgs + { + /// + /// The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The protocol number which the rule should match. Either `name` or `number` must be provided. + /// + [Input("number")] + public Input? Number { get; set; } + + public SecurityGroupRuleProtocolArgs() + { + } + public static new SecurityGroupRuleProtocolArgs Empty => new SecurityGroupRuleProtocolArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SecurityGroupRuleProtocolGetArgs.cs b/sdk/dotnet/Inputs/SecurityGroupRuleProtocolGetArgs.cs new file mode 100644 index 0000000..247d7e9 --- /dev/null +++ b/sdk/dotnet/Inputs/SecurityGroupRuleProtocolGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SecurityGroupRuleProtocolGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The protocol number which the rule should match. Either `name` or `number` must be provided. + /// + [Input("number")] + public Input? Number { get; set; } + + public SecurityGroupRuleProtocolGetArgs() + { + } + public static new SecurityGroupRuleProtocolGetArgs Empty => new SecurityGroupRuleProtocolGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesArgs.cs b/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesArgs.cs new file mode 100644 index 0000000..fe4dc67 --- /dev/null +++ b/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesArgs.cs @@ -0,0 +1,34 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ServerBackupScheduleBackupPropertiesArgs : global::Pulumi.ResourceArgs + { + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + [Input("retentionPeriod", required: true)] + public Input RetentionPeriod { get; set; } = null!; + + [Input("volumeIds")] + private InputList? _volumeIds; + public InputList VolumeIds + { + get => _volumeIds ?? (_volumeIds = new InputList()); + set => _volumeIds = value; + } + + public ServerBackupScheduleBackupPropertiesArgs() + { + } + public static new ServerBackupScheduleBackupPropertiesArgs Empty => new ServerBackupScheduleBackupPropertiesArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesGetArgs.cs b/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesGetArgs.cs new file mode 100644 index 0000000..66e6da4 --- /dev/null +++ b/sdk/dotnet/Inputs/ServerBackupScheduleBackupPropertiesGetArgs.cs @@ -0,0 +1,34 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ServerBackupScheduleBackupPropertiesGetArgs : global::Pulumi.ResourceArgs + { + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + [Input("retentionPeriod", required: true)] + public Input RetentionPeriod { get; set; } = null!; + + [Input("volumeIds")] + private InputList? _volumeIds; + public InputList VolumeIds + { + get => _volumeIds ?? (_volumeIds = new InputList()); + set => _volumeIds = value; + } + + public ServerBackupScheduleBackupPropertiesGetArgs() + { + } + public static new ServerBackupScheduleBackupPropertiesGetArgs Empty => new ServerBackupScheduleBackupPropertiesGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ServerBootVolumeArgs.cs b/sdk/dotnet/Inputs/ServerBootVolumeArgs.cs new file mode 100644 index 0000000..2c286cf --- /dev/null +++ b/sdk/dotnet/Inputs/ServerBootVolumeArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ServerBootVolumeArgs : global::Pulumi.ResourceArgs + { + /// + /// Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + /// + [Input("deleteOnTermination")] + public Input? DeleteOnTermination { get; set; } + + /// + /// The ID of the boot volume + /// + [Input("id")] + public Input? Id { get; set; } + + /// + /// The performance class of the server. + /// + [Input("performanceClass")] + public Input? PerformanceClass { get; set; } + + /// + /// The size of the boot volume in GB. Must be provided when `source_type` is `image`. + /// + [Input("size")] + public Input? Size { get; set; } + + /// + /// The ID of the source, either image ID or volume ID + /// + [Input("sourceId", required: true)] + public Input SourceId { get; set; } = null!; + + /// + /// The type of the source. Supported values are: `volume`, `image`. + /// + [Input("sourceType", required: true)] + public Input SourceType { get; set; } = null!; + + public ServerBootVolumeArgs() + { + } + public static new ServerBootVolumeArgs Empty => new ServerBootVolumeArgs(); + } +} diff --git a/sdk/dotnet/Inputs/ServerBootVolumeGetArgs.cs b/sdk/dotnet/Inputs/ServerBootVolumeGetArgs.cs new file mode 100644 index 0000000..7a8bb7d --- /dev/null +++ b/sdk/dotnet/Inputs/ServerBootVolumeGetArgs.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class ServerBootVolumeGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + /// + [Input("deleteOnTermination")] + public Input? DeleteOnTermination { get; set; } + + /// + /// The ID of the boot volume + /// + [Input("id")] + public Input? Id { get; set; } + + /// + /// The performance class of the server. + /// + [Input("performanceClass")] + public Input? PerformanceClass { get; set; } + + /// + /// The size of the boot volume in GB. Must be provided when `source_type` is `image`. + /// + [Input("size")] + public Input? Size { get; set; } + + /// + /// The ID of the source, either image ID or volume ID + /// + [Input("sourceId", required: true)] + public Input SourceId { get; set; } = null!; + + /// + /// The type of the source. Supported values are: `volume`, `image`. + /// + [Input("sourceType", required: true)] + public Input SourceType { get; set; } = null!; + + public ServerBootVolumeGetArgs() + { + } + public static new ServerBootVolumeGetArgs Empty => new ServerBootVolumeGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsAclArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsAclArgs.cs new file mode 100644 index 0000000..297cb04 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsAclArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsAclArgs : global::Pulumi.ResourceArgs + { + [Input("allowedCidrs", required: true)] + private InputList? _allowedCidrs; + + /// + /// Specify a list of CIDRs to whitelist. + /// + public InputList AllowedCidrs + { + get => _allowedCidrs ?? (_allowedCidrs = new InputList()); + set => _allowedCidrs = value; + } + + /// + /// Is ACL enabled? + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + public SkeClusterExtensionsAclArgs() + { + } + public static new SkeClusterExtensionsAclArgs Empty => new SkeClusterExtensionsAclArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsAclGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsAclGetArgs.cs new file mode 100644 index 0000000..6e1beba --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsAclGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsAclGetArgs : global::Pulumi.ResourceArgs + { + [Input("allowedCidrs", required: true)] + private InputList? _allowedCidrs; + + /// + /// Specify a list of CIDRs to whitelist. + /// + public InputList AllowedCidrs + { + get => _allowedCidrs ?? (_allowedCidrs = new InputList()); + set => _allowedCidrs = value; + } + + /// + /// Is ACL enabled? + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + public SkeClusterExtensionsAclGetArgs() + { + } + public static new SkeClusterExtensionsAclGetArgs Empty => new SkeClusterExtensionsAclGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsArgs.cs new file mode 100644 index 0000000..1a6bb47 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsArgs : global::Pulumi.ResourceArgs + { + /// + /// Cluster access control configuration. + /// + [Input("acl")] + public Input? Acl { get; set; } + + /// + /// A single argus block as defined below. + /// + [Input("argus")] + public Input? Argus { get; set; } + + /// + /// DNS extension configuration + /// + [Input("dns")] + public Input? Dns { get; set; } + + public SkeClusterExtensionsArgs() + { + } + public static new SkeClusterExtensionsArgs Empty => new SkeClusterExtensionsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsArgusArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsArgusArgs.cs new file mode 100644 index 0000000..83dd1d2 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsArgusArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsArgusArgs : global::Pulumi.ResourceArgs + { + /// + /// Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + /// + [Input("argusInstanceId")] + public Input? ArgusInstanceId { get; set; } + + /// + /// Flag to enable/disable Argus extensions. + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + public SkeClusterExtensionsArgusArgs() + { + } + public static new SkeClusterExtensionsArgusArgs Empty => new SkeClusterExtensionsArgusArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsArgusGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsArgusGetArgs.cs new file mode 100644 index 0000000..4e24d1d --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsArgusGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsArgusGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + /// + [Input("argusInstanceId")] + public Input? ArgusInstanceId { get; set; } + + /// + /// Flag to enable/disable Argus extensions. + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + public SkeClusterExtensionsArgusGetArgs() + { + } + public static new SkeClusterExtensionsArgusGetArgs Empty => new SkeClusterExtensionsArgusGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsDnsArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsDnsArgs.cs new file mode 100644 index 0000000..037ecac --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsDnsArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsDnsArgs : global::Pulumi.ResourceArgs + { + /// + /// Flag to enable/disable DNS extensions + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + [Input("zones")] + private InputList? _zones; + + /// + /// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + /// + public InputList Zones + { + get => _zones ?? (_zones = new InputList()); + set => _zones = value; + } + + public SkeClusterExtensionsDnsArgs() + { + } + public static new SkeClusterExtensionsDnsArgs Empty => new SkeClusterExtensionsDnsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsDnsGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsDnsGetArgs.cs new file mode 100644 index 0000000..a117719 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsDnsGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsDnsGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Flag to enable/disable DNS extensions + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + [Input("zones")] + private InputList? _zones; + + /// + /// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + /// + public InputList Zones + { + get => _zones ?? (_zones = new InputList()); + set => _zones = value; + } + + public SkeClusterExtensionsDnsGetArgs() + { + } + public static new SkeClusterExtensionsDnsGetArgs Empty => new SkeClusterExtensionsDnsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterExtensionsGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterExtensionsGetArgs.cs new file mode 100644 index 0000000..4807c0c --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterExtensionsGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterExtensionsGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Cluster access control configuration. + /// + [Input("acl")] + public Input? Acl { get; set; } + + /// + /// A single argus block as defined below. + /// + [Input("argus")] + public Input? Argus { get; set; } + + /// + /// DNS extension configuration + /// + [Input("dns")] + public Input? Dns { get; set; } + + public SkeClusterExtensionsGetArgs() + { + } + public static new SkeClusterExtensionsGetArgs Empty => new SkeClusterExtensionsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterHibernationArgs.cs b/sdk/dotnet/Inputs/SkeClusterHibernationArgs.cs new file mode 100644 index 0000000..254e8c1 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterHibernationArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterHibernationArgs : global::Pulumi.ResourceArgs + { + /// + /// End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + /// + [Input("end", required: true)] + public Input End { get; set; } = null!; + + /// + /// Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + /// + [Input("start", required: true)] + public Input Start { get; set; } = null!; + + /// + /// Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + /// + [Input("timezone")] + public Input? Timezone { get; set; } + + public SkeClusterHibernationArgs() + { + } + public static new SkeClusterHibernationArgs Empty => new SkeClusterHibernationArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterHibernationGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterHibernationGetArgs.cs new file mode 100644 index 0000000..46dce93 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterHibernationGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterHibernationGetArgs : global::Pulumi.ResourceArgs + { + /// + /// End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + /// + [Input("end", required: true)] + public Input End { get; set; } = null!; + + /// + /// Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + /// + [Input("start", required: true)] + public Input Start { get; set; } = null!; + + /// + /// Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + /// + [Input("timezone")] + public Input? Timezone { get; set; } + + public SkeClusterHibernationGetArgs() + { + } + public static new SkeClusterHibernationGetArgs Empty => new SkeClusterHibernationGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterMaintenanceArgs.cs b/sdk/dotnet/Inputs/SkeClusterMaintenanceArgs.cs new file mode 100644 index 0000000..62fc6ef --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterMaintenanceArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterMaintenanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("enableKubernetesVersionUpdates")] + public Input? EnableKubernetesVersionUpdates { get; set; } + + /// + /// Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("enableMachineImageVersionUpdates")] + public Input? EnableMachineImageVersionUpdates { get; set; } + + /// + /// Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + [Input("end", required: true)] + public Input End { get; set; } = null!; + + /// + /// Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + [Input("start", required: true)] + public Input Start { get; set; } = null!; + + public SkeClusterMaintenanceArgs() + { + } + public static new SkeClusterMaintenanceArgs Empty => new SkeClusterMaintenanceArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterMaintenanceGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterMaintenanceGetArgs.cs new file mode 100644 index 0000000..9ed7355 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterMaintenanceGetArgs.cs @@ -0,0 +1,44 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterMaintenanceGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("enableKubernetesVersionUpdates")] + public Input? EnableKubernetesVersionUpdates { get; set; } + + /// + /// Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("enableMachineImageVersionUpdates")] + public Input? EnableMachineImageVersionUpdates { get; set; } + + /// + /// Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + [Input("end", required: true)] + public Input End { get; set; } = null!; + + /// + /// Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + [Input("start", required: true)] + public Input Start { get; set; } = null!; + + public SkeClusterMaintenanceGetArgs() + { + } + public static new SkeClusterMaintenanceGetArgs Empty => new SkeClusterMaintenanceGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNetworkArgs.cs b/sdk/dotnet/Inputs/SkeClusterNetworkArgs.cs new file mode 100644 index 0000000..b020372 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNetworkArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNetworkArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + /// + [Input("id")] + public Input? Id { get; set; } + + public SkeClusterNetworkArgs() + { + } + public static new SkeClusterNetworkArgs Empty => new SkeClusterNetworkArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNetworkGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterNetworkGetArgs.cs new file mode 100644 index 0000000..df10b6b --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNetworkGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNetworkGetArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + /// + [Input("id")] + public Input? Id { get; set; } + + public SkeClusterNetworkGetArgs() + { + } + public static new SkeClusterNetworkGetArgs Empty => new SkeClusterNetworkGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNodePoolArgs.cs b/sdk/dotnet/Inputs/SkeClusterNodePoolArgs.cs new file mode 100644 index 0000000..7ecfcf8 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNodePoolArgs.cs @@ -0,0 +1,140 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNodePoolArgs : global::Pulumi.ResourceArgs + { + /// + /// Allow system components to run on this node pool. + /// + [Input("allowSystemComponents")] + public Input? AllowSystemComponents { get; set; } + + [Input("availabilityZones", required: true)] + private InputList? _availabilityZones; + + /// + /// Specify a list of availability zones. E.g. `eu01-m` + /// + public InputList AvailabilityZones + { + get => _availabilityZones ?? (_availabilityZones = new InputList()); + set => _availabilityZones = value; + } + + /// + /// Specifies the container runtime. Defaults to `containerd` + /// + [Input("cri")] + public Input? Cri { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels to add to each node. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The machine type. + /// + [Input("machineType", required: true)] + public Input MachineType { get; set; } = null!; + + /// + /// Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + [Input("maxSurge")] + public Input? MaxSurge { get; set; } + + /// + /// Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + [Input("maxUnavailable")] + public Input? MaxUnavailable { get; set; } + + /// + /// Maximum number of nodes in the pool. + /// + [Input("maximum", required: true)] + public Input Maximum { get; set; } = null!; + + /// + /// Minimum number of nodes in the pool. + /// + [Input("minimum", required: true)] + public Input Minimum { get; set; } = null!; + + /// + /// Specifies the name of the node pool. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// The name of the OS image. Defaults to `flatcar`. + /// + [Input("osName")] + public Input? OsName { get; set; } + + /// + /// This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + /// + [Input("osVersion")] + public Input? OsVersion { get; set; } + + /// + /// The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + /// + [Input("osVersionMin")] + public Input? OsVersionMin { get; set; } + + /// + /// Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("osVersionUsed")] + public Input? OsVersionUsed { get; set; } + + [Input("taints")] + private InputList? _taints; + + /// + /// Specifies a taint list as defined below. + /// + public InputList Taints + { + get => _taints ?? (_taints = new InputList()); + set => _taints = value; + } + + /// + /// The volume size in GB. Defaults to `20` + /// + [Input("volumeSize")] + public Input? VolumeSize { get; set; } + + /// + /// Specifies the volume type. Defaults to `storage_premium_perf1`. + /// + [Input("volumeType")] + public Input? VolumeType { get; set; } + + public SkeClusterNodePoolArgs() + { + } + public static new SkeClusterNodePoolArgs Empty => new SkeClusterNodePoolArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNodePoolGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterNodePoolGetArgs.cs new file mode 100644 index 0000000..400e35f --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNodePoolGetArgs.cs @@ -0,0 +1,140 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNodePoolGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Allow system components to run on this node pool. + /// + [Input("allowSystemComponents")] + public Input? AllowSystemComponents { get; set; } + + [Input("availabilityZones", required: true)] + private InputList? _availabilityZones; + + /// + /// Specify a list of availability zones. E.g. `eu01-m` + /// + public InputList AvailabilityZones + { + get => _availabilityZones ?? (_availabilityZones = new InputList()); + set => _availabilityZones = value; + } + + /// + /// Specifies the container runtime. Defaults to `containerd` + /// + [Input("cri")] + public Input? Cri { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels to add to each node. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The machine type. + /// + [Input("machineType", required: true)] + public Input MachineType { get; set; } = null!; + + /// + /// Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + [Input("maxSurge")] + public Input? MaxSurge { get; set; } + + /// + /// Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + [Input("maxUnavailable")] + public Input? MaxUnavailable { get; set; } + + /// + /// Maximum number of nodes in the pool. + /// + [Input("maximum", required: true)] + public Input Maximum { get; set; } = null!; + + /// + /// Minimum number of nodes in the pool. + /// + [Input("minimum", required: true)] + public Input Minimum { get; set; } = null!; + + /// + /// Specifies the name of the node pool. + /// + [Input("name", required: true)] + public Input Name { get; set; } = null!; + + /// + /// The name of the OS image. Defaults to `flatcar`. + /// + [Input("osName")] + public Input? OsName { get; set; } + + /// + /// This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + /// + [Input("osVersion")] + public Input? OsVersion { get; set; } + + /// + /// The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + /// + [Input("osVersionMin")] + public Input? OsVersionMin { get; set; } + + /// + /// Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("osVersionUsed")] + public Input? OsVersionUsed { get; set; } + + [Input("taints")] + private InputList? _taints; + + /// + /// Specifies a taint list as defined below. + /// + public InputList Taints + { + get => _taints ?? (_taints = new InputList()); + set => _taints = value; + } + + /// + /// The volume size in GB. Defaults to `20` + /// + [Input("volumeSize")] + public Input? VolumeSize { get; set; } + + /// + /// Specifies the volume type. Defaults to `storage_premium_perf1`. + /// + [Input("volumeType")] + public Input? VolumeType { get; set; } + + public SkeClusterNodePoolGetArgs() + { + } + public static new SkeClusterNodePoolGetArgs Empty => new SkeClusterNodePoolGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNodePoolTaintArgs.cs b/sdk/dotnet/Inputs/SkeClusterNodePoolTaintArgs.cs new file mode 100644 index 0000000..4bb59b4 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNodePoolTaintArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNodePoolTaintArgs : global::Pulumi.ResourceArgs + { + /// + /// The taint effect. E.g `PreferNoSchedule`. + /// + [Input("effect", required: true)] + public Input Effect { get; set; } = null!; + + /// + /// Taint key to be applied to a node. + /// + [Input("key", required: true)] + public Input Key { get; set; } = null!; + + /// + /// Taint value corresponding to the taint key. + /// + [Input("value")] + public Input? Value { get; set; } + + public SkeClusterNodePoolTaintArgs() + { + } + public static new SkeClusterNodePoolTaintArgs Empty => new SkeClusterNodePoolTaintArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SkeClusterNodePoolTaintGetArgs.cs b/sdk/dotnet/Inputs/SkeClusterNodePoolTaintGetArgs.cs new file mode 100644 index 0000000..27bab14 --- /dev/null +++ b/sdk/dotnet/Inputs/SkeClusterNodePoolTaintGetArgs.cs @@ -0,0 +1,38 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SkeClusterNodePoolTaintGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The taint effect. E.g `PreferNoSchedule`. + /// + [Input("effect", required: true)] + public Input Effect { get; set; } = null!; + + /// + /// Taint key to be applied to a node. + /// + [Input("key", required: true)] + public Input Key { get; set; } = null!; + + /// + /// Taint value corresponding to the taint key. + /// + [Input("value")] + public Input? Value { get; set; } + + public SkeClusterNodePoolTaintGetArgs() + { + } + public static new SkeClusterNodePoolTaintGetArgs Empty => new SkeClusterNodePoolTaintGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorArgs.cs new file mode 100644 index 0000000..43aea9d --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceFlavorArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public SqlserverflexInstanceFlavorArgs() + { + } + public static new SqlserverflexInstanceFlavorArgs Empty => new SqlserverflexInstanceFlavorArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorGetArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorGetArgs.cs new file mode 100644 index 0000000..f755ff8 --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceFlavorGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceFlavorGetArgs : global::Pulumi.ResourceArgs + { + [Input("cpu", required: true)] + public Input Cpu { get; set; } = null!; + + [Input("description")] + public Input? Description { get; set; } + + [Input("id")] + public Input? Id { get; set; } + + [Input("ram", required: true)] + public Input Ram { get; set; } = null!; + + public SqlserverflexInstanceFlavorGetArgs() + { + } + public static new SqlserverflexInstanceFlavorGetArgs Empty => new SqlserverflexInstanceFlavorGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsArgs.cs new file mode 100644 index 0000000..867c4b4 --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceOptionsArgs : global::Pulumi.ResourceArgs + { + [Input("edition")] + public Input? Edition { get; set; } + + [Input("retentionDays")] + public Input? RetentionDays { get; set; } + + public SqlserverflexInstanceOptionsArgs() + { + } + public static new SqlserverflexInstanceOptionsArgs Empty => new SqlserverflexInstanceOptionsArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsGetArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsGetArgs.cs new file mode 100644 index 0000000..ccfbab2 --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceOptionsGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceOptionsGetArgs : global::Pulumi.ResourceArgs + { + [Input("edition")] + public Input? Edition { get; set; } + + [Input("retentionDays")] + public Input? RetentionDays { get; set; } + + public SqlserverflexInstanceOptionsGetArgs() + { + } + public static new SqlserverflexInstanceOptionsGetArgs Empty => new SqlserverflexInstanceOptionsGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceStorageArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceStorageArgs.cs new file mode 100644 index 0000000..aca2310 --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceStorageArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceStorageArgs : global::Pulumi.ResourceArgs + { + [Input("class")] + public Input? Class { get; set; } + + [Input("size")] + public Input? Size { get; set; } + + public SqlserverflexInstanceStorageArgs() + { + } + public static new SqlserverflexInstanceStorageArgs Empty => new SqlserverflexInstanceStorageArgs(); + } +} diff --git a/sdk/dotnet/Inputs/SqlserverflexInstanceStorageGetArgs.cs b/sdk/dotnet/Inputs/SqlserverflexInstanceStorageGetArgs.cs new file mode 100644 index 0000000..08c039b --- /dev/null +++ b/sdk/dotnet/Inputs/SqlserverflexInstanceStorageGetArgs.cs @@ -0,0 +1,26 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class SqlserverflexInstanceStorageGetArgs : global::Pulumi.ResourceArgs + { + [Input("class")] + public Input? Class { get; set; } + + [Input("size")] + public Input? Size { get; set; } + + public SqlserverflexInstanceStorageGetArgs() + { + } + public static new SqlserverflexInstanceStorageGetArgs Empty => new SqlserverflexInstanceStorageGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/VolumeSourceArgs.cs b/sdk/dotnet/Inputs/VolumeSourceArgs.cs new file mode 100644 index 0000000..ef05af5 --- /dev/null +++ b/sdk/dotnet/Inputs/VolumeSourceArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class VolumeSourceArgs : global::Pulumi.ResourceArgs + { + /// + /// The ID of the source, e.g. image ID + /// + [Input("id", required: true)] + public Input Id { get; set; } = null!; + + /// + /// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public VolumeSourceArgs() + { + } + public static new VolumeSourceArgs Empty => new VolumeSourceArgs(); + } +} diff --git a/sdk/dotnet/Inputs/VolumeSourceGetArgs.cs b/sdk/dotnet/Inputs/VolumeSourceGetArgs.cs new file mode 100644 index 0000000..cf56618 --- /dev/null +++ b/sdk/dotnet/Inputs/VolumeSourceGetArgs.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Inputs +{ + + public sealed class VolumeSourceGetArgs : global::Pulumi.ResourceArgs + { + /// + /// The ID of the source, e.g. image ID + /// + [Input("id", required: true)] + public Input Id { get; set; } = null!; + + /// + /// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + /// + [Input("type", required: true)] + public Input Type { get; set; } = null!; + + public VolumeSourceGetArgs() + { + } + public static new VolumeSourceGetArgs Empty => new VolumeSourceGetArgs(); + } +} diff --git a/sdk/dotnet/KeyPair.cs b/sdk/dotnet/KeyPair.cs new file mode 100644 index 0000000..1b8138b --- /dev/null +++ b/sdk/dotnet/KeyPair.cs @@ -0,0 +1,156 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication. + /// + [StackitResourceType("stackit:index/keyPair:KeyPair")] + public partial class KeyPair : global::Pulumi.CustomResource + { + /// + /// The fingerprint of the public SSH key. + /// + [Output("fingerprint")] + public Output Fingerprint { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The name of the SSH key pair. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// A string representation of the public SSH key. E.g., `ssh-rsa <key_data>` or `ssh-ed25519 <key-data>`. + /// + [Output("publicKey")] + public Output PublicKey { get; private set; } = null!; + + + /// + /// Create a KeyPair 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 KeyPair(string name, KeyPairArgs args, CustomResourceOptions? options = null) + : base("stackit:index/keyPair:KeyPair", name, args ?? new KeyPairArgs(), MakeResourceOptions(options, "")) + { + } + + private KeyPair(string name, Input id, KeyPairState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/keyPair:KeyPair", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 KeyPair 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 KeyPair Get(string name, Input id, KeyPairState? state = null, CustomResourceOptions? options = null) + { + return new KeyPair(name, id, state, options); + } + } + + public sealed class KeyPairArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the SSH key pair. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// A string representation of the public SSH key. E.g., `ssh-rsa <key_data>` or `ssh-ed25519 <key-data>`. + /// + [Input("publicKey", required: true)] + public Input PublicKey { get; set; } = null!; + + public KeyPairArgs() + { + } + public static new KeyPairArgs Empty => new KeyPairArgs(); + } + + public sealed class KeyPairState : global::Pulumi.ResourceArgs + { + /// + /// The fingerprint of the public SSH key. + /// + [Input("fingerprint")] + public Input? Fingerprint { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the SSH key pair. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// A string representation of the public SSH key. E.g., `ssh-rsa <key_data>` or `ssh-ed25519 <key-data>`. + /// + [Input("publicKey")] + public Input? PublicKey { get; set; } + + public KeyPairState() + { + } + public static new KeyPairState Empty => new KeyPairState(); + } +} diff --git a/sdk/dotnet/Loadbalancer.cs b/sdk/dotnet/Loadbalancer.cs new file mode 100644 index 0000000..8423031 --- /dev/null +++ b/sdk/dotnet/Loadbalancer.cs @@ -0,0 +1,270 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/loadbalancer:Loadbalancer")] + public partial class Loadbalancer : global::Pulumi.CustomResource + { + /// + /// External Load Balancer IP address where this Load Balancer is exposed. + /// + [Output("externalAddress")] + public Output ExternalAddress { get; private set; } = null!; + + /// + /// List of all listeners which will accept traffic. Limited to 20. + /// + [Output("listeners")] + public Output> Listeners { get; private set; } = null!; + + /// + /// Load balancer name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// List of networks that listeners and targets reside in. + /// + [Output("networks")] + public Output> Networks { get; private set; } = null!; + + /// + /// Defines any optional functionality you want to have enabled on your load balancer. + /// + [Output("options")] + public Output Options { get; private set; } = null!; + + /// + /// Transient private Load Balancer IP address. It can change any time. + /// + [Output("privateAddress")] + public Output PrivateAddress { get; private set; } = null!; + + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// List of all target pools which will be used in the Load Balancer. Limited to 20. + /// + [Output("targetPools")] + public Output> TargetPools { get; private set; } = null!; + + + /// + /// Create a Loadbalancer 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 Loadbalancer(string name, LoadbalancerArgs args, CustomResourceOptions? options = null) + : base("stackit:index/loadbalancer:Loadbalancer", name, args ?? new LoadbalancerArgs(), MakeResourceOptions(options, "")) + { + } + + private Loadbalancer(string name, Input id, LoadbalancerState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/loadbalancer:Loadbalancer", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Loadbalancer 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 Loadbalancer Get(string name, Input id, LoadbalancerState? state = null, CustomResourceOptions? options = null) + { + return new Loadbalancer(name, id, state, options); + } + } + + public sealed class LoadbalancerArgs : global::Pulumi.ResourceArgs + { + /// + /// External Load Balancer IP address where this Load Balancer is exposed. + /// + [Input("externalAddress")] + public Input? ExternalAddress { get; set; } + + [Input("listeners", required: true)] + private InputList? _listeners; + + /// + /// List of all listeners which will accept traffic. Limited to 20. + /// + public InputList Listeners + { + get => _listeners ?? (_listeners = new InputList()); + set => _listeners = value; + } + + /// + /// Load balancer name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("networks", required: true)] + private InputList? _networks; + + /// + /// List of networks that listeners and targets reside in. + /// + public InputList Networks + { + get => _networks ?? (_networks = new InputList()); + set => _networks = value; + } + + /// + /// Defines any optional functionality you want to have enabled on your load balancer. + /// + [Input("options")] + public Input? Options { get; set; } + + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("targetPools", required: true)] + private InputList? _targetPools; + + /// + /// List of all target pools which will be used in the Load Balancer. Limited to 20. + /// + public InputList TargetPools + { + get => _targetPools ?? (_targetPools = new InputList()); + set => _targetPools = value; + } + + public LoadbalancerArgs() + { + } + public static new LoadbalancerArgs Empty => new LoadbalancerArgs(); + } + + public sealed class LoadbalancerState : global::Pulumi.ResourceArgs + { + /// + /// External Load Balancer IP address where this Load Balancer is exposed. + /// + [Input("externalAddress")] + public Input? ExternalAddress { get; set; } + + [Input("listeners")] + private InputList? _listeners; + + /// + /// List of all listeners which will accept traffic. Limited to 20. + /// + public InputList Listeners + { + get => _listeners ?? (_listeners = new InputList()); + set => _listeners = value; + } + + /// + /// Load balancer name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("networks")] + private InputList? _networks; + + /// + /// List of networks that listeners and targets reside in. + /// + public InputList Networks + { + get => _networks ?? (_networks = new InputList()); + set => _networks = value; + } + + /// + /// Defines any optional functionality you want to have enabled on your load balancer. + /// + [Input("options")] + public Input? Options { get; set; } + + /// + /// Transient private Load Balancer IP address. It can change any time. + /// + [Input("privateAddress")] + public Input? PrivateAddress { get; set; } + + /// + /// STACKIT project ID to which the Load Balancer is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("targetPools")] + private InputList? _targetPools; + + /// + /// List of all target pools which will be used in the Load Balancer. Limited to 20. + /// + public InputList TargetPools + { + get => _targetPools ?? (_targetPools = new InputList()); + set => _targetPools = value; + } + + public LoadbalancerState() + { + } + public static new LoadbalancerState Empty => new LoadbalancerState(); + } +} diff --git a/sdk/dotnet/LoadbalancerObservabilityCredential.cs b/sdk/dotnet/LoadbalancerObservabilityCredential.cs new file mode 100644 index 0000000..cecc41a --- /dev/null +++ b/sdk/dotnet/LoadbalancerObservabilityCredential.cs @@ -0,0 +1,182 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential")] + public partial class LoadbalancerObservabilityCredential : global::Pulumi.CustomResource + { + /// + /// The credentials reference is used by the Load Balancer to define which credentials it will use. + /// + [Output("credentialsRef")] + public Output CredentialsRef { get; private set; } = null!; + + /// + /// Observability credential name. + /// + [Output("displayName")] + public Output DisplayName { get; private set; } = null!; + + /// + /// The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Output("password")] + public Output Password { get; private set; } = null!; + + /// + /// STACKIT project ID to which the load balancer observability credential is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a LoadbalancerObservabilityCredential 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 LoadbalancerObservabilityCredential(string name, LoadbalancerObservabilityCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential", name, args ?? new LoadbalancerObservabilityCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private LoadbalancerObservabilityCredential(string name, Input id, LoadbalancerObservabilityCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 LoadbalancerObservabilityCredential 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 LoadbalancerObservabilityCredential Get(string name, Input id, LoadbalancerObservabilityCredentialState? state = null, CustomResourceOptions? options = null) + { + return new LoadbalancerObservabilityCredential(name, id, state, options); + } + } + + public sealed class LoadbalancerObservabilityCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// Observability credential name. + /// + [Input("displayName", required: true)] + public Input DisplayName { get; set; } = null!; + + /// + /// The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Input("password", required: true)] + public Input Password { get; set; } = null!; + + /// + /// STACKIT project ID to which the load balancer observability credential is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public LoadbalancerObservabilityCredentialArgs() + { + } + public static new LoadbalancerObservabilityCredentialArgs Empty => new LoadbalancerObservabilityCredentialArgs(); + } + + public sealed class LoadbalancerObservabilityCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credentials reference is used by the Load Balancer to define which credentials it will use. + /// + [Input("credentialsRef")] + public Input? CredentialsRef { get; set; } + + /// + /// Observability credential name. + /// + [Input("displayName")] + public Input? DisplayName { get; set; } + + /// + /// The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Input("password")] + public Input? Password { get; set; } + + /// + /// STACKIT project ID to which the load balancer observability credential is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + /// + [Input("username")] + public Input? Username { get; set; } + + public LoadbalancerObservabilityCredentialState() + { + } + public static new LoadbalancerObservabilityCredentialState Empty => new LoadbalancerObservabilityCredentialState(); + } +} diff --git a/sdk/dotnet/LogmeCredential.cs b/sdk/dotnet/LogmeCredential.cs new file mode 100644 index 0000000..60b1957 --- /dev/null +++ b/sdk/dotnet/LogmeCredential.cs @@ -0,0 +1,181 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// LogMe credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/logmeCredential:LogmeCredential")] + public partial class LogmeCredential : global::Pulumi.CustomResource + { + /// + /// The credential's ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + /// + /// ID of the LogMe instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a LogmeCredential 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 LogmeCredential(string name, LogmeCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/logmeCredential:LogmeCredential", name, args ?? new LogmeCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private LogmeCredential(string name, Input id, LogmeCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/logmeCredential:LogmeCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 LogmeCredential 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 LogmeCredential Get(string name, Input id, LogmeCredentialState? state = null, CustomResourceOptions? options = null) + { + return new LogmeCredential(name, id, state, options); + } + } + + public sealed class LogmeCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the LogMe instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public LogmeCredentialArgs() + { + } + public static new LogmeCredentialArgs Empty => new LogmeCredentialArgs(); + } + + public sealed class LogmeCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + /// + /// ID of the LogMe instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("username")] + public Input? Username { get; set; } + + public LogmeCredentialState() + { + } + public static new LogmeCredentialState Empty => new LogmeCredentialState(); + } +} diff --git a/sdk/dotnet/LogmeInstance.cs b/sdk/dotnet/LogmeInstance.cs new file mode 100644 index 0000000..445d613 --- /dev/null +++ b/sdk/dotnet/LogmeInstance.cs @@ -0,0 +1,215 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// LogMe instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/logmeInstance:LogmeInstance")] + public partial class LogmeInstance : global::Pulumi.CustomResource + { + [Output("cfGuid")] + public Output CfGuid { get; private set; } = null!; + + [Output("cfOrganizationGuid")] + public Output CfOrganizationGuid { get; private set; } = null!; + + [Output("cfSpaceGuid")] + public Output CfSpaceGuid { get; private set; } = null!; + + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + [Output("imageUrl")] + public Output ImageUrl { get; private set; } = null!; + + /// + /// ID of the LogMe instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("parameters")] + public Output Parameters { get; private set; } = null!; + + /// + /// The selected plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// The selected plan name. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The service version. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a LogmeInstance 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 LogmeInstance(string name, LogmeInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/logmeInstance:LogmeInstance", name, args ?? new LogmeInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private LogmeInstance(string name, Input id, LogmeInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/logmeInstance:LogmeInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 LogmeInstance 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 LogmeInstance Get(string name, Input id, LogmeInstanceState? state = null, CustomResourceOptions? options = null) + { + return new LogmeInstance(name, id, state, options); + } + } + + public sealed class LogmeInstanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The service version. + /// + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public LogmeInstanceArgs() + { + } + public static new LogmeInstanceArgs Empty => new LogmeInstanceArgs(); + } + + public sealed class LogmeInstanceState : global::Pulumi.ResourceArgs + { + [Input("cfGuid")] + public Input? CfGuid { get; set; } + + [Input("cfOrganizationGuid")] + public Input? CfOrganizationGuid { get; set; } + + [Input("cfSpaceGuid")] + public Input? CfSpaceGuid { get; set; } + + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("imageUrl")] + public Input? ImageUrl { get; set; } + + /// + /// ID of the LogMe instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The service version. + /// + [Input("version")] + public Input? Version { get; set; } + + public LogmeInstanceState() + { + } + public static new LogmeInstanceState Empty => new LogmeInstanceState(); + } +} diff --git a/sdk/dotnet/MariadbCredential.cs b/sdk/dotnet/MariadbCredential.cs new file mode 100644 index 0000000..7a9449a --- /dev/null +++ b/sdk/dotnet/MariadbCredential.cs @@ -0,0 +1,198 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// MariaDB credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/mariadbCredential:MariadbCredential")] + public partial class MariadbCredential : global::Pulumi.CustomResource + { + /// + /// The credential's ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + [Output("hosts")] + public Output> Hosts { get; private set; } = null!; + + /// + /// ID of the MariaDB instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a MariadbCredential 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 MariadbCredential(string name, MariadbCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/mariadbCredential:MariadbCredential", name, args ?? new MariadbCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private MariadbCredential(string name, Input id, MariadbCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/mariadbCredential:MariadbCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 MariadbCredential 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 MariadbCredential Get(string name, Input id, MariadbCredentialState? state = null, CustomResourceOptions? options = null) + { + return new MariadbCredential(name, id, state, options); + } + } + + public sealed class MariadbCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public MariadbCredentialArgs() + { + } + public static new MariadbCredentialArgs Empty => new MariadbCredentialArgs(); + } + + public sealed class MariadbCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + [Input("hosts")] + private InputList? _hosts; + public InputList Hosts + { + get => _hosts ?? (_hosts = new InputList()); + set => _hosts = value; + } + + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("name")] + public Input? Name { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("username")] + public Input? Username { get; set; } + + public MariadbCredentialState() + { + } + public static new MariadbCredentialState Empty => new MariadbCredentialState(); + } +} diff --git a/sdk/dotnet/MariadbInstance.cs b/sdk/dotnet/MariadbInstance.cs new file mode 100644 index 0000000..3081832 --- /dev/null +++ b/sdk/dotnet/MariadbInstance.cs @@ -0,0 +1,215 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// MariaDB instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/mariadbInstance:MariadbInstance")] + public partial class MariadbInstance : global::Pulumi.CustomResource + { + [Output("cfGuid")] + public Output CfGuid { get; private set; } = null!; + + [Output("cfOrganizationGuid")] + public Output CfOrganizationGuid { get; private set; } = null!; + + [Output("cfSpaceGuid")] + public Output CfSpaceGuid { get; private set; } = null!; + + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + [Output("imageUrl")] + public Output ImageUrl { get; private set; } = null!; + + /// + /// ID of the MariaDB instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("parameters")] + public Output Parameters { get; private set; } = null!; + + /// + /// The selected plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// The selected plan name. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The service version. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a MariadbInstance 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 MariadbInstance(string name, MariadbInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/mariadbInstance:MariadbInstance", name, args ?? new MariadbInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private MariadbInstance(string name, Input id, MariadbInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/mariadbInstance:MariadbInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 MariadbInstance 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 MariadbInstance Get(string name, Input id, MariadbInstanceState? state = null, CustomResourceOptions? options = null) + { + return new MariadbInstance(name, id, state, options); + } + } + + public sealed class MariadbInstanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The service version. + /// + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public MariadbInstanceArgs() + { + } + public static new MariadbInstanceArgs Empty => new MariadbInstanceArgs(); + } + + public sealed class MariadbInstanceState : global::Pulumi.ResourceArgs + { + [Input("cfGuid")] + public Input? CfGuid { get; set; } + + [Input("cfOrganizationGuid")] + public Input? CfOrganizationGuid { get; set; } + + [Input("cfSpaceGuid")] + public Input? CfSpaceGuid { get; set; } + + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("imageUrl")] + public Input? ImageUrl { get; set; } + + /// + /// ID of the MariaDB instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The service version. + /// + [Input("version")] + public Input? Version { get; set; } + + public MariadbInstanceState() + { + } + public static new MariadbInstanceState Empty => new MariadbInstanceState(); + } +} diff --git a/sdk/dotnet/ModelservingToken.cs b/sdk/dotnet/ModelservingToken.cs new file mode 100644 index 0000000..ef94271 --- /dev/null +++ b/sdk/dotnet/ModelservingToken.cs @@ -0,0 +1,264 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// AI Model Serving Auth Token Resource schema. + /// + /// ## Example Usage + /// + /// ### Automatically rotate AI model serving token + /// + [StackitResourceType("stackit:index/modelservingToken:ModelservingToken")] + public partial class ModelservingToken : global::Pulumi.CustomResource + { + /// + /// The description of the AI model serving auth token. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// Name of the AI model serving auth token. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the AI model serving auth token is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Region to which the AI model serving auth token is associated. If not defined, the provider region is used + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + [Output("rotateWhenChanged")] + public Output?> RotateWhenChanged { get; private set; } = null!; + + /// + /// State of the AI model serving auth token. + /// + [Output("state")] + public Output State { get; private set; } = null!; + + /// + /// Content of the AI model serving auth token. + /// + [Output("token")] + public Output Token { get; private set; } = null!; + + /// + /// The AI model serving auth token ID. + /// + [Output("tokenId")] + public Output TokenId { get; private set; } = null!; + + /// + /// The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + /// + [Output("ttlDuration")] + public Output TtlDuration { get; private set; } = null!; + + /// + /// The time until the AI model serving auth token is valid. + /// + [Output("validUntil")] + public Output ValidUntil { get; private set; } = null!; + + + /// + /// Create a ModelservingToken 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 ModelservingToken(string name, ModelservingTokenArgs args, CustomResourceOptions? options = null) + : base("stackit:index/modelservingToken:ModelservingToken", name, args ?? new ModelservingTokenArgs(), MakeResourceOptions(options, "")) + { + } + + private ModelservingToken(string name, Input id, ModelservingTokenState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/modelservingToken:ModelservingToken", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "token", + }, + }; + 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 ModelservingToken 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 ModelservingToken Get(string name, Input id, ModelservingTokenState? state = null, CustomResourceOptions? options = null) + { + return new ModelservingToken(name, id, state, options); + } + } + + public sealed class ModelservingTokenArgs : global::Pulumi.ResourceArgs + { + /// + /// The description of the AI model serving auth token. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// Name of the AI model serving auth token. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the AI model serving auth token is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// Region to which the AI model serving auth token is associated. If not defined, the provider region is used + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + /// + [Input("ttlDuration")] + public Input? TtlDuration { get; set; } + + public ModelservingTokenArgs() + { + } + public static new ModelservingTokenArgs Empty => new ModelservingTokenArgs(); + } + + public sealed class ModelservingTokenState : global::Pulumi.ResourceArgs + { + /// + /// The description of the AI model serving auth token. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// Name of the AI model serving auth token. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the AI model serving auth token is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Region to which the AI model serving auth token is associated. If not defined, the provider region is used + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// State of the AI model serving auth token. + /// + [Input("state")] + public Input? State { get; set; } + + [Input("token")] + private Input? _token; + + /// + /// Content of the AI model serving auth token. + /// + public Input? Token + { + get => _token; + set + { + var emptySecret = Output.CreateSecret(0); + _token = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// The AI model serving auth token ID. + /// + [Input("tokenId")] + public Input? TokenId { get; set; } + + /// + /// The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + /// + [Input("ttlDuration")] + public Input? TtlDuration { get; set; } + + /// + /// The time until the AI model serving auth token is valid. + /// + [Input("validUntil")] + public Input? ValidUntil { get; set; } + + public ModelservingTokenState() + { + } + public static new ModelservingTokenState Empty => new ModelservingTokenState(); + } +} diff --git a/sdk/dotnet/MongodbflexInstance.cs b/sdk/dotnet/MongodbflexInstance.cs new file mode 100644 index 0000000..d81de02 --- /dev/null +++ b/sdk/dotnet/MongodbflexInstance.cs @@ -0,0 +1,221 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/mongodbflexInstance:MongodbflexInstance")] + public partial class MongodbflexInstance : global::Pulumi.CustomResource + { + /// + /// The Access Control List (ACL) for the MongoDB Flex instance. + /// + [Output("acls")] + public Output> Acls { get; private set; } = null!; + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + /// + [Output("backupSchedule")] + public Output BackupSchedule { get; private set; } = null!; + + [Output("flavor")] + public Output Flavor { get; private set; } = null!; + + /// + /// ID of the MongoDB Flex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("options")] + public Output Options { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("replicas")] + public Output Replicas { get; private set; } = null!; + + [Output("storage")] + public Output Storage { get; private set; } = null!; + + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a MongodbflexInstance 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 MongodbflexInstance(string name, MongodbflexInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/mongodbflexInstance:MongodbflexInstance", name, args ?? new MongodbflexInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private MongodbflexInstance(string name, Input id, MongodbflexInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/mongodbflexInstance:MongodbflexInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 MongodbflexInstance 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 MongodbflexInstance Get(string name, Input id, MongodbflexInstanceState? state = null, CustomResourceOptions? options = null) + { + return new MongodbflexInstance(name, id, state, options); + } + } + + public sealed class MongodbflexInstanceArgs : global::Pulumi.ResourceArgs + { + [Input("acls", required: true)] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the MongoDB Flex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + /// + [Input("backupSchedule", required: true)] + public Input BackupSchedule { get; set; } = null!; + + [Input("flavor", required: true)] + public Input Flavor { get; set; } = null!; + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("options", required: true)] + public Input Options { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("replicas", required: true)] + public Input Replicas { get; set; } = null!; + + [Input("storage", required: true)] + public Input Storage { get; set; } = null!; + + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public MongodbflexInstanceArgs() + { + } + public static new MongodbflexInstanceArgs Empty => new MongodbflexInstanceArgs(); + } + + public sealed class MongodbflexInstanceState : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the MongoDB Flex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + /// + [Input("backupSchedule")] + public Input? BackupSchedule { get; set; } + + [Input("flavor")] + public Input? Flavor { get; set; } + + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("options")] + public Input? Options { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("replicas")] + public Input? Replicas { get; set; } + + [Input("storage")] + public Input? Storage { get; set; } + + [Input("version")] + public Input? Version { get; set; } + + public MongodbflexInstanceState() + { + } + public static new MongodbflexInstanceState Empty => new MongodbflexInstanceState(); + } +} diff --git a/sdk/dotnet/MongodbflexUser.cs b/sdk/dotnet/MongodbflexUser.cs new file mode 100644 index 0000000..67d335d --- /dev/null +++ b/sdk/dotnet/MongodbflexUser.cs @@ -0,0 +1,223 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/mongodbflexUser:MongodbflexUser")] + public partial class MongodbflexUser : global::Pulumi.CustomResource + { + [Output("database")] + public Output Database { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + /// + /// ID of the MongoDB Flex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + /// + [Output("roles")] + public Output> Roles { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + /// + /// User ID. + /// + [Output("userId")] + public Output UserId { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a MongodbflexUser 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 MongodbflexUser(string name, MongodbflexUserArgs args, CustomResourceOptions? options = null) + : base("stackit:index/mongodbflexUser:MongodbflexUser", name, args ?? new MongodbflexUserArgs(), MakeResourceOptions(options, "")) + { + } + + private MongodbflexUser(string name, Input id, MongodbflexUserState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/mongodbflexUser:MongodbflexUser", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 MongodbflexUser 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 MongodbflexUser Get(string name, Input id, MongodbflexUserState? state = null, CustomResourceOptions? options = null) + { + return new MongodbflexUser(name, id, state, options); + } + } + + public sealed class MongodbflexUserArgs : global::Pulumi.ResourceArgs + { + [Input("database", required: true)] + public Input Database { get; set; } = null!; + + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("roles", required: true)] + private InputList? _roles; + + /// + /// Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + [Input("username")] + public Input? Username { get; set; } + + public MongodbflexUserArgs() + { + } + public static new MongodbflexUserArgs Empty => new MongodbflexUserArgs(); + } + + public sealed class MongodbflexUserState : global::Pulumi.ResourceArgs + { + [Input("database")] + public Input? Database { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + /// + /// ID of the MongoDB Flex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("roles")] + private InputList? _roles; + + /// + /// Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// User ID. + /// + [Input("userId")] + public Input? UserId { get; set; } + + [Input("username")] + public Input? Username { get; set; } + + public MongodbflexUserState() + { + } + public static new MongodbflexUserState Empty => new MongodbflexUserState(); + } +} diff --git a/sdk/dotnet/Network.cs b/sdk/dotnet/Network.cs new file mode 100644 index 0000000..07208ba --- /dev/null +++ b/sdk/dotnet/Network.cs @@ -0,0 +1,479 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Network resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/network:Network")] + public partial class Network : global::Pulumi.CustomResource + { + /// + /// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Output("ipv4Gateway")] + public Output Ipv4Gateway { get; private set; } = null!; + + /// + /// The IPv4 nameservers of the network. + /// + [Output("ipv4Nameservers")] + public Output> Ipv4Nameservers { get; private set; } = null!; + + /// + /// The IPv4 prefix of the network (CIDR). + /// + [Output("ipv4Prefix")] + public Output Ipv4Prefix { get; private set; } = null!; + + /// + /// The IPv4 prefix length of the network. + /// + [Output("ipv4PrefixLength")] + public Output Ipv4PrefixLength { get; private set; } = null!; + + /// + /// The IPv4 prefixes of the network. + /// + [Output("ipv4Prefixes")] + public Output> Ipv4Prefixes { get; private set; } = null!; + + /// + /// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Output("ipv6Gateway")] + public Output Ipv6Gateway { get; private set; } = null!; + + /// + /// The IPv6 nameservers of the network. + /// + [Output("ipv6Nameservers")] + public Output> Ipv6Nameservers { get; private set; } = null!; + + /// + /// The IPv6 prefix of the network (CIDR). + /// + [Output("ipv6Prefix")] + public Output Ipv6Prefix { get; private set; } = null!; + + /// + /// The IPv6 prefix length of the network. + /// + [Output("ipv6PrefixLength")] + public Output Ipv6PrefixLength { get; private set; } = null!; + + /// + /// The IPv6 prefixes of the network. + /// + [Output("ipv6Prefixes")] + public Output> Ipv6Prefixes { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The name of the network. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + /// + [Output("nameservers")] + public Output> Nameservers { get; private set; } = null!; + + /// + /// The network ID. + /// + [Output("networkId")] + public Output NetworkId { get; private set; } = null!; + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Output("noIpv4Gateway")] + public Output NoIpv4Gateway { get; private set; } = null!; + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Output("noIpv6Gateway")] + public Output NoIpv6Gateway { get; private set; } = null!; + + /// + /// The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + /// + [Output("prefixes")] + public Output> Prefixes { get; private set; } = null!; + + /// + /// STACKIT project ID to which the network is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The public IP of the network. + /// + [Output("publicIp")] + public Output PublicIp { get; private set; } = null!; + + /// + /// If set to `true`, the network is routed and therefore accessible from other networks. + /// + [Output("routed")] + public Output Routed { get; private set; } = null!; + + + /// + /// Create a Network 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 Network(string name, NetworkArgs args, CustomResourceOptions? options = null) + : base("stackit:index/network:Network", name, args ?? new NetworkArgs(), MakeResourceOptions(options, "")) + { + } + + private Network(string name, Input id, NetworkState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/network:Network", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Network 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 Network Get(string name, Input id, NetworkState? state = null, CustomResourceOptions? options = null) + { + return new Network(name, id, state, options); + } + } + + public sealed class NetworkArgs : global::Pulumi.ResourceArgs + { + /// + /// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Input("ipv4Gateway")] + public Input? Ipv4Gateway { get; set; } + + [Input("ipv4Nameservers")] + private InputList? _ipv4Nameservers; + + /// + /// The IPv4 nameservers of the network. + /// + public InputList Ipv4Nameservers + { + get => _ipv4Nameservers ?? (_ipv4Nameservers = new InputList()); + set => _ipv4Nameservers = value; + } + + /// + /// The IPv4 prefix of the network (CIDR). + /// + [Input("ipv4Prefix")] + public Input? Ipv4Prefix { get; set; } + + /// + /// The IPv4 prefix length of the network. + /// + [Input("ipv4PrefixLength")] + public Input? Ipv4PrefixLength { get; set; } + + /// + /// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Input("ipv6Gateway")] + public Input? Ipv6Gateway { get; set; } + + [Input("ipv6Nameservers")] + private InputList? _ipv6Nameservers; + + /// + /// The IPv6 nameservers of the network. + /// + public InputList Ipv6Nameservers + { + get => _ipv6Nameservers ?? (_ipv6Nameservers = new InputList()); + set => _ipv6Nameservers = value; + } + + /// + /// The IPv6 prefix of the network (CIDR). + /// + [Input("ipv6Prefix")] + public Input? Ipv6Prefix { get; set; } + + /// + /// The IPv6 prefix length of the network. + /// + [Input("ipv6PrefixLength")] + public Input? Ipv6PrefixLength { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the network. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("nameservers")] + private InputList? _nameservers; + + /// + /// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + /// + [Obsolete(@"Use `ipv4_nameservers` to configure the nameservers for IPv4.")] + public InputList Nameservers + { + get => _nameservers ?? (_nameservers = new InputList()); + set => _nameservers = value; + } + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Input("noIpv4Gateway")] + public Input? NoIpv4Gateway { get; set; } + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Input("noIpv6Gateway")] + public Input? NoIpv6Gateway { get; set; } + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// If set to `true`, the network is routed and therefore accessible from other networks. + /// + [Input("routed")] + public Input? Routed { get; set; } + + public NetworkArgs() + { + } + public static new NetworkArgs Empty => new NetworkArgs(); + } + + public sealed class NetworkState : global::Pulumi.ResourceArgs + { + /// + /// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Input("ipv4Gateway")] + public Input? Ipv4Gateway { get; set; } + + [Input("ipv4Nameservers")] + private InputList? _ipv4Nameservers; + + /// + /// The IPv4 nameservers of the network. + /// + public InputList Ipv4Nameservers + { + get => _ipv4Nameservers ?? (_ipv4Nameservers = new InputList()); + set => _ipv4Nameservers = value; + } + + /// + /// The IPv4 prefix of the network (CIDR). + /// + [Input("ipv4Prefix")] + public Input? Ipv4Prefix { get; set; } + + /// + /// The IPv4 prefix length of the network. + /// + [Input("ipv4PrefixLength")] + public Input? Ipv4PrefixLength { get; set; } + + [Input("ipv4Prefixes")] + private InputList? _ipv4Prefixes; + + /// + /// The IPv4 prefixes of the network. + /// + public InputList Ipv4Prefixes + { + get => _ipv4Prefixes ?? (_ipv4Prefixes = new InputList()); + set => _ipv4Prefixes = value; + } + + /// + /// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + /// + [Input("ipv6Gateway")] + public Input? Ipv6Gateway { get; set; } + + [Input("ipv6Nameservers")] + private InputList? _ipv6Nameservers; + + /// + /// The IPv6 nameservers of the network. + /// + public InputList Ipv6Nameservers + { + get => _ipv6Nameservers ?? (_ipv6Nameservers = new InputList()); + set => _ipv6Nameservers = value; + } + + /// + /// The IPv6 prefix of the network (CIDR). + /// + [Input("ipv6Prefix")] + public Input? Ipv6Prefix { get; set; } + + /// + /// The IPv6 prefix length of the network. + /// + [Input("ipv6PrefixLength")] + public Input? Ipv6PrefixLength { get; set; } + + [Input("ipv6Prefixes")] + private InputList? _ipv6Prefixes; + + /// + /// The IPv6 prefixes of the network. + /// + public InputList Ipv6Prefixes + { + get => _ipv6Prefixes ?? (_ipv6Prefixes = new InputList()); + set => _ipv6Prefixes = value; + } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the network. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("nameservers")] + private InputList? _nameservers; + + /// + /// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + /// + [Obsolete(@"Use `ipv4_nameservers` to configure the nameservers for IPv4.")] + public InputList Nameservers + { + get => _nameservers ?? (_nameservers = new InputList()); + set => _nameservers = value; + } + + /// + /// The network ID. + /// + [Input("networkId")] + public Input? NetworkId { get; set; } + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Input("noIpv4Gateway")] + public Input? NoIpv4Gateway { get; set; } + + /// + /// If set to `true`, the network doesn't have a gateway. + /// + [Input("noIpv6Gateway")] + public Input? NoIpv6Gateway { get; set; } + + [Input("prefixes")] + private InputList? _prefixes; + + /// + /// The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + /// + [Obsolete(@"Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.")] + public InputList Prefixes + { + get => _prefixes ?? (_prefixes = new InputList()); + set => _prefixes = value; + } + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The public IP of the network. + /// + [Input("publicIp")] + public Input? PublicIp { get; set; } + + /// + /// If set to `true`, the network is routed and therefore accessible from other networks. + /// + [Input("routed")] + public Input? Routed { get; set; } + + public NetworkState() + { + } + public static new NetworkState Empty => new NetworkState(); + } +} diff --git a/sdk/dotnet/NetworkArea.cs b/sdk/dotnet/NetworkArea.cs new file mode 100644 index 0000000..567a30f --- /dev/null +++ b/sdk/dotnet/NetworkArea.cs @@ -0,0 +1,302 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Network area resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/networkArea:NetworkArea")] + public partial class NetworkArea : global::Pulumi.CustomResource + { + /// + /// List of DNS Servers/Nameservers. + /// + [Output("defaultNameservers")] + public Output> DefaultNameservers { get; private set; } = null!; + + /// + /// The default prefix length for networks in the network area. + /// + [Output("defaultPrefixLength")] + public Output DefaultPrefixLength { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The maximal prefix length for networks in the network area. + /// + [Output("maxPrefixLength")] + public Output MaxPrefixLength { get; private set; } = null!; + + /// + /// The minimal prefix length for networks in the network area. + /// + [Output("minPrefixLength")] + public Output MinPrefixLength { get; private set; } = null!; + + /// + /// The name of the network area. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The network area ID. + /// + [Output("networkAreaId")] + public Output NetworkAreaId { get; private set; } = null!; + + /// + /// List of Network ranges. + /// + [Output("networkRanges")] + public Output> NetworkRanges { get; private set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Output("organizationId")] + public Output OrganizationId { get; private set; } = null!; + + /// + /// The amount of projects currently referencing this area. + /// + [Output("projectCount")] + public Output ProjectCount { get; private set; } = null!; + + /// + /// Classless Inter-Domain Routing (CIDR). + /// + [Output("transferNetwork")] + public Output TransferNetwork { get; private set; } = null!; + + + /// + /// Create a NetworkArea 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 NetworkArea(string name, NetworkAreaArgs args, CustomResourceOptions? options = null) + : base("stackit:index/networkArea:NetworkArea", name, args ?? new NetworkAreaArgs(), MakeResourceOptions(options, "")) + { + } + + private NetworkArea(string name, Input id, NetworkAreaState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/networkArea:NetworkArea", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 NetworkArea 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 NetworkArea Get(string name, Input id, NetworkAreaState? state = null, CustomResourceOptions? options = null) + { + return new NetworkArea(name, id, state, options); + } + } + + public sealed class NetworkAreaArgs : global::Pulumi.ResourceArgs + { + [Input("defaultNameservers")] + private InputList? _defaultNameservers; + + /// + /// List of DNS Servers/Nameservers. + /// + public InputList DefaultNameservers + { + get => _defaultNameservers ?? (_defaultNameservers = new InputList()); + set => _defaultNameservers = value; + } + + /// + /// The default prefix length for networks in the network area. + /// + [Input("defaultPrefixLength")] + public Input? DefaultPrefixLength { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The maximal prefix length for networks in the network area. + /// + [Input("maxPrefixLength")] + public Input? MaxPrefixLength { get; set; } + + /// + /// The minimal prefix length for networks in the network area. + /// + [Input("minPrefixLength")] + public Input? MinPrefixLength { get; set; } + + /// + /// The name of the network area. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("networkRanges", required: true)] + private InputList? _networkRanges; + + /// + /// List of Network ranges. + /// + public InputList NetworkRanges + { + get => _networkRanges ?? (_networkRanges = new InputList()); + set => _networkRanges = value; + } + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public Input OrganizationId { get; set; } = null!; + + /// + /// Classless Inter-Domain Routing (CIDR). + /// + [Input("transferNetwork", required: true)] + public Input TransferNetwork { get; set; } = null!; + + public NetworkAreaArgs() + { + } + public static new NetworkAreaArgs Empty => new NetworkAreaArgs(); + } + + public sealed class NetworkAreaState : global::Pulumi.ResourceArgs + { + [Input("defaultNameservers")] + private InputList? _defaultNameservers; + + /// + /// List of DNS Servers/Nameservers. + /// + public InputList DefaultNameservers + { + get => _defaultNameservers ?? (_defaultNameservers = new InputList()); + set => _defaultNameservers = value; + } + + /// + /// The default prefix length for networks in the network area. + /// + [Input("defaultPrefixLength")] + public Input? DefaultPrefixLength { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The maximal prefix length for networks in the network area. + /// + [Input("maxPrefixLength")] + public Input? MaxPrefixLength { get; set; } + + /// + /// The minimal prefix length for networks in the network area. + /// + [Input("minPrefixLength")] + public Input? MinPrefixLength { get; set; } + + /// + /// The name of the network area. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The network area ID. + /// + [Input("networkAreaId")] + public Input? NetworkAreaId { get; set; } + + [Input("networkRanges")] + private InputList? _networkRanges; + + /// + /// List of Network ranges. + /// + public InputList NetworkRanges + { + get => _networkRanges ?? (_networkRanges = new InputList()); + set => _networkRanges = value; + } + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId")] + public Input? OrganizationId { get; set; } + + /// + /// The amount of projects currently referencing this area. + /// + [Input("projectCount")] + public Input? ProjectCount { get; set; } + + /// + /// Classless Inter-Domain Routing (CIDR). + /// + [Input("transferNetwork")] + public Input? TransferNetwork { get; set; } + + public NetworkAreaState() + { + } + public static new NetworkAreaState Empty => new NetworkAreaState(); + } +} diff --git a/sdk/dotnet/NetworkAreaRoute.cs b/sdk/dotnet/NetworkAreaRoute.cs new file mode 100644 index 0000000..06e3872 --- /dev/null +++ b/sdk/dotnet/NetworkAreaRoute.cs @@ -0,0 +1,194 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Network area route resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/networkAreaRoute:NetworkAreaRoute")] + public partial class NetworkAreaRoute : global::Pulumi.CustomResource + { + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The network area ID to which the network area route is associated. + /// + [Output("networkAreaId")] + public Output NetworkAreaId { get; private set; } = null!; + + /// + /// The network area route ID. + /// + [Output("networkAreaRouteId")] + public Output NetworkAreaRouteId { get; private set; } = null!; + + /// + /// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + /// + [Output("nextHop")] + public Output NextHop { get; private set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Output("organizationId")] + public Output OrganizationId { get; private set; } = null!; + + /// + /// The network, that is reachable though the Next Hop. Should use CIDR notation. + /// + [Output("prefix")] + public Output Prefix { get; private set; } = null!; + + + /// + /// Create a NetworkAreaRoute 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 NetworkAreaRoute(string name, NetworkAreaRouteArgs args, CustomResourceOptions? options = null) + : base("stackit:index/networkAreaRoute:NetworkAreaRoute", name, args ?? new NetworkAreaRouteArgs(), MakeResourceOptions(options, "")) + { + } + + private NetworkAreaRoute(string name, Input id, NetworkAreaRouteState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/networkAreaRoute:NetworkAreaRoute", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 NetworkAreaRoute 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 NetworkAreaRoute Get(string name, Input id, NetworkAreaRouteState? state = null, CustomResourceOptions? options = null) + { + return new NetworkAreaRoute(name, id, state, options); + } + } + + public sealed class NetworkAreaRouteArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The network area ID to which the network area route is associated. + /// + [Input("networkAreaId", required: true)] + public Input NetworkAreaId { get; set; } = null!; + + /// + /// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + /// + [Input("nextHop", required: true)] + public Input NextHop { get; set; } = null!; + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId", required: true)] + public Input OrganizationId { get; set; } = null!; + + /// + /// The network, that is reachable though the Next Hop. Should use CIDR notation. + /// + [Input("prefix", required: true)] + public Input Prefix { get; set; } = null!; + + public NetworkAreaRouteArgs() + { + } + public static new NetworkAreaRouteArgs Empty => new NetworkAreaRouteArgs(); + } + + public sealed class NetworkAreaRouteState : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The network area ID to which the network area route is associated. + /// + [Input("networkAreaId")] + public Input? NetworkAreaId { get; set; } + + /// + /// The network area route ID. + /// + [Input("networkAreaRouteId")] + public Input? NetworkAreaRouteId { get; set; } + + /// + /// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + /// + [Input("nextHop")] + public Input? NextHop { get; set; } + + /// + /// STACKIT organization ID to which the network area is associated. + /// + [Input("organizationId")] + public Input? OrganizationId { get; set; } + + /// + /// The network, that is reachable though the Next Hop. Should use CIDR notation. + /// + [Input("prefix")] + public Input? Prefix { get; set; } + + public NetworkAreaRouteState() + { + } + public static new NetworkAreaRouteState Empty => new NetworkAreaRouteState(); + } +} diff --git a/sdk/dotnet/NetworkInterface.cs b/sdk/dotnet/NetworkInterface.cs new file mode 100644 index 0000000..a2623d4 --- /dev/null +++ b/sdk/dotnet/NetworkInterface.cs @@ -0,0 +1,308 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Network interface resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/networkInterface:NetworkInterface")] + public partial class NetworkInterface : global::Pulumi.CustomResource + { + /// + /// The list of CIDR (Classless Inter-Domain Routing) notations. + /// + [Output("allowedAddresses")] + public Output> AllowedAddresses { get; private set; } = null!; + + /// + /// The device UUID of the network interface. + /// + [Output("device")] + public Output Device { get; private set; } = null!; + + /// + /// The IPv4 address. + /// + [Output("ipv4")] + public Output Ipv4 { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a network interface. + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The MAC address of network interface. + /// + [Output("mac")] + public Output Mac { get; private set; } = null!; + + /// + /// The name of the network interface. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The network ID to which the network interface is associated. + /// + [Output("networkId")] + public Output NetworkId { get; private set; } = null!; + + /// + /// The network interface ID. + /// + [Output("networkInterfaceId")] + public Output NetworkInterfaceId { get; private set; } = null!; + + /// + /// STACKIT project ID to which the network is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The Network Interface Security. If set to false, then no security groups will apply to this network interface. + /// + [Output("security")] + public Output Security { get; private set; } = null!; + + /// + /// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + /// + [Output("securityGroupIds")] + public Output> SecurityGroupIds { get; private set; } = null!; + + /// + /// Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + /// + [Output("type")] + public Output Type { get; private set; } = null!; + + + /// + /// Create a NetworkInterface 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 NetworkInterface(string name, NetworkInterfaceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/networkInterface:NetworkInterface", name, args ?? new NetworkInterfaceArgs(), MakeResourceOptions(options, "")) + { + } + + private NetworkInterface(string name, Input id, NetworkInterfaceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/networkInterface:NetworkInterface", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 NetworkInterface 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 NetworkInterface Get(string name, Input id, NetworkInterfaceState? state = null, CustomResourceOptions? options = null) + { + return new NetworkInterface(name, id, state, options); + } + } + + public sealed class NetworkInterfaceArgs : global::Pulumi.ResourceArgs + { + [Input("allowedAddresses")] + private InputList? _allowedAddresses; + + /// + /// The list of CIDR (Classless Inter-Domain Routing) notations. + /// + public InputList AllowedAddresses + { + get => _allowedAddresses ?? (_allowedAddresses = new InputList()); + set => _allowedAddresses = value; + } + + /// + /// The IPv4 address. + /// + [Input("ipv4")] + public Input? Ipv4 { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a network interface. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the network interface. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The network ID to which the network interface is associated. + /// + [Input("networkId", required: true)] + public Input NetworkId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The Network Interface Security. If set to false, then no security groups will apply to this network interface. + /// + [Input("security")] + public Input? Security { get; set; } + + [Input("securityGroupIds")] + private InputList? _securityGroupIds; + + /// + /// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + /// + public InputList SecurityGroupIds + { + get => _securityGroupIds ?? (_securityGroupIds = new InputList()); + set => _securityGroupIds = value; + } + + public NetworkInterfaceArgs() + { + } + public static new NetworkInterfaceArgs Empty => new NetworkInterfaceArgs(); + } + + public sealed class NetworkInterfaceState : global::Pulumi.ResourceArgs + { + [Input("allowedAddresses")] + private InputList? _allowedAddresses; + + /// + /// The list of CIDR (Classless Inter-Domain Routing) notations. + /// + public InputList AllowedAddresses + { + get => _allowedAddresses ?? (_allowedAddresses = new InputList()); + set => _allowedAddresses = value; + } + + /// + /// The device UUID of the network interface. + /// + [Input("device")] + public Input? Device { get; set; } + + /// + /// The IPv4 address. + /// + [Input("ipv4")] + public Input? Ipv4 { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a network interface. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The MAC address of network interface. + /// + [Input("mac")] + public Input? Mac { get; set; } + + /// + /// The name of the network interface. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The network ID to which the network interface is associated. + /// + [Input("networkId")] + public Input? NetworkId { get; set; } + + /// + /// The network interface ID. + /// + [Input("networkInterfaceId")] + public Input? NetworkInterfaceId { get; set; } + + /// + /// STACKIT project ID to which the network is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The Network Interface Security. If set to false, then no security groups will apply to this network interface. + /// + [Input("security")] + public Input? Security { get; set; } + + [Input("securityGroupIds")] + private InputList? _securityGroupIds; + + /// + /// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + /// + public InputList SecurityGroupIds + { + get => _securityGroupIds ?? (_securityGroupIds = new InputList()); + set => _securityGroupIds = value; + } + + /// + /// Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + /// + [Input("type")] + public Input? Type { get; set; } + + public NetworkInterfaceState() + { + } + public static new NetworkInterfaceState Empty => new NetworkInterfaceState(); + } +} diff --git a/sdk/dotnet/ObjectstorageBucket.cs b/sdk/dotnet/ObjectstorageBucket.cs new file mode 100644 index 0000000..80cb434 --- /dev/null +++ b/sdk/dotnet/ObjectstorageBucket.cs @@ -0,0 +1,146 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/objectstorageBucket:ObjectstorageBucket")] + public partial class ObjectstorageBucket : global::Pulumi.CustomResource + { + /// + /// The bucket name. It must be DNS conform. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the bucket is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + [Output("urlPathStyle")] + public Output UrlPathStyle { get; private set; } = null!; + + [Output("urlVirtualHostedStyle")] + public Output UrlVirtualHostedStyle { get; private set; } = null!; + + + /// + /// Create a ObjectstorageBucket 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 ObjectstorageBucket(string name, ObjectstorageBucketArgs args, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageBucket:ObjectstorageBucket", name, args ?? new ObjectstorageBucketArgs(), MakeResourceOptions(options, "")) + { + } + + private ObjectstorageBucket(string name, Input id, ObjectstorageBucketState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageBucket:ObjectstorageBucket", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ObjectstorageBucket 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 ObjectstorageBucket Get(string name, Input id, ObjectstorageBucketState? state = null, CustomResourceOptions? options = null) + { + return new ObjectstorageBucket(name, id, state, options); + } + } + + public sealed class ObjectstorageBucketArgs : global::Pulumi.ResourceArgs + { + /// + /// The bucket name. It must be DNS conform. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the bucket is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public ObjectstorageBucketArgs() + { + } + public static new ObjectstorageBucketArgs Empty => new ObjectstorageBucketArgs(); + } + + public sealed class ObjectstorageBucketState : global::Pulumi.ResourceArgs + { + /// + /// The bucket name. It must be DNS conform. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the bucket is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("urlPathStyle")] + public Input? UrlPathStyle { get; set; } + + [Input("urlVirtualHostedStyle")] + public Input? UrlVirtualHostedStyle { get; set; } + + public ObjectstorageBucketState() + { + } + public static new ObjectstorageBucketState Empty => new ObjectstorageBucketState(); + } +} diff --git a/sdk/dotnet/ObjectstorageCredential.cs b/sdk/dotnet/ObjectstorageCredential.cs new file mode 100644 index 0000000..e0d6d2e --- /dev/null +++ b/sdk/dotnet/ObjectstorageCredential.cs @@ -0,0 +1,195 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/objectstorageCredential:ObjectstorageCredential")] + public partial class ObjectstorageCredential : global::Pulumi.CustomResource + { + [Output("accessKey")] + public Output AccessKey { get; private set; } = null!; + + /// + /// The credential ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + /// + /// The credential group ID. + /// + [Output("credentialsGroupId")] + public Output CredentialsGroupId { get; private set; } = null!; + + /// + /// Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + /// + [Output("expirationTimestamp")] + public Output ExpirationTimestamp { get; private set; } = null!; + + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the credential group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + [Output("secretAccessKey")] + public Output SecretAccessKey { get; private set; } = null!; + + + /// + /// Create a ObjectstorageCredential 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 ObjectstorageCredential(string name, ObjectstorageCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageCredential:ObjectstorageCredential", name, args ?? new ObjectstorageCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private ObjectstorageCredential(string name, Input id, ObjectstorageCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageCredential:ObjectstorageCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "secretAccessKey", + }, + }; + 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 ObjectstorageCredential 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 ObjectstorageCredential Get(string name, Input id, ObjectstorageCredentialState? state = null, CustomResourceOptions? options = null) + { + return new ObjectstorageCredential(name, id, state, options); + } + } + + public sealed class ObjectstorageCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// The credential group ID. + /// + [Input("credentialsGroupId", required: true)] + public Input CredentialsGroupId { get; set; } = null!; + + /// + /// Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + /// + [Input("expirationTimestamp")] + public Input? ExpirationTimestamp { get; set; } + + /// + /// STACKIT Project ID to which the credential group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public ObjectstorageCredentialArgs() + { + } + public static new ObjectstorageCredentialArgs Empty => new ObjectstorageCredentialArgs(); + } + + public sealed class ObjectstorageCredentialState : global::Pulumi.ResourceArgs + { + [Input("accessKey")] + public Input? AccessKey { get; set; } + + /// + /// The credential ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + /// + /// The credential group ID. + /// + [Input("credentialsGroupId")] + public Input? CredentialsGroupId { get; set; } + + /// + /// Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + /// + [Input("expirationTimestamp")] + public Input? ExpirationTimestamp { get; set; } + + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the credential group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("secretAccessKey")] + private Input? _secretAccessKey; + public Input? SecretAccessKey + { + get => _secretAccessKey; + set + { + var emptySecret = Output.CreateSecret(0); + _secretAccessKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + public ObjectstorageCredentialState() + { + } + public static new ObjectstorageCredentialState Empty => new ObjectstorageCredentialState(); + } +} diff --git a/sdk/dotnet/ObjectstorageCredentialsGroup.cs b/sdk/dotnet/ObjectstorageCredentialsGroup.cs new file mode 100644 index 0000000..0c912e8 --- /dev/null +++ b/sdk/dotnet/ObjectstorageCredentialsGroup.cs @@ -0,0 +1,158 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup")] + public partial class ObjectstorageCredentialsGroup : global::Pulumi.CustomResource + { + /// + /// The credentials group ID + /// + [Output("credentialsGroupId")] + public Output CredentialsGroupId { get; private set; } = null!; + + /// + /// The credentials group's display name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// Project ID to which the credentials group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Credentials group uniform resource name (URN) + /// + [Output("urn")] + public Output Urn { get; private set; } = null!; + + + /// + /// Create a ObjectstorageCredentialsGroup 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 ObjectstorageCredentialsGroup(string name, ObjectstorageCredentialsGroupArgs args, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup", name, args ?? new ObjectstorageCredentialsGroupArgs(), MakeResourceOptions(options, "")) + { + } + + private ObjectstorageCredentialsGroup(string name, Input id, ObjectstorageCredentialsGroupState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ObjectstorageCredentialsGroup 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 ObjectstorageCredentialsGroup Get(string name, Input id, ObjectstorageCredentialsGroupState? state = null, CustomResourceOptions? options = null) + { + return new ObjectstorageCredentialsGroup(name, id, state, options); + } + } + + public sealed class ObjectstorageCredentialsGroupArgs : global::Pulumi.ResourceArgs + { + /// + /// The credentials group's display name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Project ID to which the credentials group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public ObjectstorageCredentialsGroupArgs() + { + } + public static new ObjectstorageCredentialsGroupArgs Empty => new ObjectstorageCredentialsGroupArgs(); + } + + public sealed class ObjectstorageCredentialsGroupState : global::Pulumi.ResourceArgs + { + /// + /// The credentials group ID + /// + [Input("credentialsGroupId")] + public Input? CredentialsGroupId { get; set; } + + /// + /// The credentials group's display name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Project ID to which the credentials group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Credentials group uniform resource name (URN) + /// + [Input("urn")] + public Input? Urn { get; set; } + + public ObjectstorageCredentialsGroupState() + { + } + public static new ObjectstorageCredentialsGroupState Empty => new ObjectstorageCredentialsGroupState(); + } +} diff --git a/sdk/dotnet/ObservabilityAlertgroup.cs b/sdk/dotnet/ObservabilityAlertgroup.cs new file mode 100644 index 0000000..5b2f6c7 --- /dev/null +++ b/sdk/dotnet/ObservabilityAlertgroup.cs @@ -0,0 +1,182 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup")] + public partial class ObservabilityAlertgroup : global::Pulumi.CustomResource + { + /// + /// Observability instance ID to which the alert group is associated. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Output("interval")] + public Output Interval { get; private set; } = null!; + + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the alert group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Rules for the alert group + /// + [Output("rules")] + public Output> Rules { get; private set; } = null!; + + + /// + /// Create a ObservabilityAlertgroup 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 ObservabilityAlertgroup(string name, ObservabilityAlertgroupArgs args, CustomResourceOptions? options = null) + : base("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup", name, args ?? new ObservabilityAlertgroupArgs(), MakeResourceOptions(options, "")) + { + } + + private ObservabilityAlertgroup(string name, Input id, ObservabilityAlertgroupState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ObservabilityAlertgroup 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 ObservabilityAlertgroup Get(string name, Input id, ObservabilityAlertgroupState? state = null, CustomResourceOptions? options = null) + { + return new ObservabilityAlertgroup(name, id, state, options); + } + } + + public sealed class ObservabilityAlertgroupArgs : global::Pulumi.ResourceArgs + { + /// + /// Observability instance ID to which the alert group is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the alert group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("rules", required: true)] + private InputList? _rules; + + /// + /// Rules for the alert group + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public ObservabilityAlertgroupArgs() + { + } + public static new ObservabilityAlertgroupArgs Empty => new ObservabilityAlertgroupArgs(); + } + + public sealed class ObservabilityAlertgroupState : global::Pulumi.ResourceArgs + { + /// + /// Observability instance ID to which the alert group is associated. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// The name of the alert group. Is the identifier and must be unique in the group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the alert group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("rules")] + private InputList? _rules; + + /// + /// Rules for the alert group + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public ObservabilityAlertgroupState() + { + } + public static new ObservabilityAlertgroupState Empty => new ObservabilityAlertgroupState(); + } +} diff --git a/sdk/dotnet/ObservabilityCredential.cs b/sdk/dotnet/ObservabilityCredential.cs new file mode 100644 index 0000000..e7385ae --- /dev/null +++ b/sdk/dotnet/ObservabilityCredential.cs @@ -0,0 +1,154 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Observability credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/observabilityCredential:ObservabilityCredential")] + public partial class ObservabilityCredential : global::Pulumi.CustomResource + { + /// + /// The Observability Instance ID the credential belongs to. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Credential password + /// + [Output("password")] + public Output Password { get; private set; } = null!; + + /// + /// STACKIT project ID to which the credential is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Credential username + /// + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a ObservabilityCredential 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 ObservabilityCredential(string name, ObservabilityCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/observabilityCredential:ObservabilityCredential", name, args ?? new ObservabilityCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private ObservabilityCredential(string name, Input id, ObservabilityCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/observabilityCredential:ObservabilityCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + }, + }; + 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 ObservabilityCredential 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 ObservabilityCredential Get(string name, Input id, ObservabilityCredentialState? state = null, CustomResourceOptions? options = null) + { + return new ObservabilityCredential(name, id, state, options); + } + } + + public sealed class ObservabilityCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// The Observability Instance ID the credential belongs to. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the credential is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public ObservabilityCredentialArgs() + { + } + public static new ObservabilityCredentialArgs Empty => new ObservabilityCredentialArgs(); + } + + public sealed class ObservabilityCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The Observability Instance ID the credential belongs to. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + + /// + /// Credential password + /// + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// STACKIT project ID to which the credential is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Credential username + /// + [Input("username")] + public Input? Username { get; set; } + + public ObservabilityCredentialState() + { + } + public static new ObservabilityCredentialState Empty => new ObservabilityCredentialState(); + } +} diff --git a/sdk/dotnet/ObservabilityInstance.cs b/sdk/dotnet/ObservabilityInstance.cs new file mode 100644 index 0000000..45deff9 --- /dev/null +++ b/sdk/dotnet/ObservabilityInstance.cs @@ -0,0 +1,472 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Observability instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/observabilityInstance:ObservabilityInstance")] + public partial class ObservabilityInstance : global::Pulumi.CustomResource + { + /// + /// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + /// + [Output("acls")] + public Output> Acls { get; private set; } = null!; + + /// + /// Alert configuration for the instance. + /// + [Output("alertConfig")] + public Output AlertConfig { get; private set; } = null!; + + /// + /// Specifies Alerting URL. + /// + [Output("alertingUrl")] + public Output AlertingUrl { get; private set; } = null!; + + /// + /// Specifies Observability instance dashboard URL. + /// + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + /// + /// Specifies an initial Grafana admin password. + /// + [Output("grafanaInitialAdminPassword")] + public Output GrafanaInitialAdminPassword { get; private set; } = null!; + + /// + /// Specifies an initial Grafana admin username. + /// + [Output("grafanaInitialAdminUser")] + public Output GrafanaInitialAdminUser { get; private set; } = null!; + + /// + /// If true, anyone can access Grafana dashboards without logging in. + /// + [Output("grafanaPublicReadAccess")] + public Output GrafanaPublicReadAccess { get; private set; } = null!; + + /// + /// Specifies Grafana URL. + /// + [Output("grafanaUrl")] + public Output GrafanaUrl { get; private set; } = null!; + + /// + /// The Observability instance ID. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Specifies if the instance can be updated. + /// + [Output("isUpdatable")] + public Output IsUpdatable { get; private set; } = null!; + + [Output("jaegerTracesUrl")] + public Output JaegerTracesUrl { get; private set; } = null!; + + [Output("jaegerUiUrl")] + public Output JaegerUiUrl { get; private set; } = null!; + + /// + /// Specifies URL for pushing logs. + /// + [Output("logsPushUrl")] + public Output LogsPushUrl { get; private set; } = null!; + + /// + /// Specifies Logs URL. + /// + [Output("logsUrl")] + public Output LogsUrl { get; private set; } = null!; + + /// + /// Specifies URL for pushing metrics. + /// + [Output("metricsPushUrl")] + public Output MetricsPushUrl { get; private set; } = null!; + + /// + /// Specifies for how many days the raw metrics are kept. + /// + [Output("metricsRetentionDays")] + public Output MetricsRetentionDays { get; private set; } = null!; + + /// + /// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + /// + [Output("metricsRetentionDays1hDownsampling")] + public Output MetricsRetentionDays1hDownsampling { get; private set; } = null!; + + /// + /// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + /// + [Output("metricsRetentionDays5mDownsampling")] + public Output MetricsRetentionDays5mDownsampling { get; private set; } = null!; + + /// + /// Specifies metrics URL. + /// + [Output("metricsUrl")] + public Output MetricsUrl { get; private set; } = null!; + + /// + /// The name of the Observability instance. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("otlpTracesUrl")] + public Output OtlpTracesUrl { get; private set; } = null!; + + /// + /// Additional parameters. + /// + [Output("parameters")] + public Output> Parameters { get; private set; } = null!; + + /// + /// The Observability plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Specifies Targets URL. + /// + [Output("targetsUrl")] + public Output TargetsUrl { get; private set; } = null!; + + [Output("zipkinSpansUrl")] + public Output ZipkinSpansUrl { get; private set; } = null!; + + + /// + /// Create a ObservabilityInstance 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 ObservabilityInstance(string name, ObservabilityInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/observabilityInstance:ObservabilityInstance", name, args ?? new ObservabilityInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private ObservabilityInstance(string name, Input id, ObservabilityInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/observabilityInstance:ObservabilityInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "grafanaInitialAdminPassword", + }, + }; + 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 ObservabilityInstance 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 ObservabilityInstance Get(string name, Input id, ObservabilityInstanceState? state = null, CustomResourceOptions? options = null) + { + return new ObservabilityInstance(name, id, state, options); + } + } + + public sealed class ObservabilityInstanceArgs : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// Alert configuration for the instance. + /// + [Input("alertConfig")] + public Input? AlertConfig { get; set; } + + /// + /// Specifies for how many days the raw metrics are kept. + /// + [Input("metricsRetentionDays")] + public Input? MetricsRetentionDays { get; set; } + + /// + /// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + /// + [Input("metricsRetentionDays1hDownsampling")] + public Input? MetricsRetentionDays1hDownsampling { get; set; } + + /// + /// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + /// + [Input("metricsRetentionDays5mDownsampling")] + public Input? MetricsRetentionDays5mDownsampling { get; set; } + + /// + /// The name of the Observability instance. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + private InputMap? _parameters; + + /// + /// Additional parameters. + /// + public InputMap Parameters + { + get => _parameters ?? (_parameters = new InputMap()); + set => _parameters = value; + } + + /// + /// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public ObservabilityInstanceArgs() + { + } + public static new ObservabilityInstanceArgs Empty => new ObservabilityInstanceArgs(); + } + + public sealed class ObservabilityInstanceState : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// Alert configuration for the instance. + /// + [Input("alertConfig")] + public Input? AlertConfig { get; set; } + + /// + /// Specifies Alerting URL. + /// + [Input("alertingUrl")] + public Input? AlertingUrl { get; set; } + + /// + /// Specifies Observability instance dashboard URL. + /// + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("grafanaInitialAdminPassword")] + private Input? _grafanaInitialAdminPassword; + + /// + /// Specifies an initial Grafana admin password. + /// + public Input? GrafanaInitialAdminPassword + { + get => _grafanaInitialAdminPassword; + set + { + var emptySecret = Output.CreateSecret(0); + _grafanaInitialAdminPassword = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// Specifies an initial Grafana admin username. + /// + [Input("grafanaInitialAdminUser")] + public Input? GrafanaInitialAdminUser { get; set; } + + /// + /// If true, anyone can access Grafana dashboards without logging in. + /// + [Input("grafanaPublicReadAccess")] + public Input? GrafanaPublicReadAccess { get; set; } + + /// + /// Specifies Grafana URL. + /// + [Input("grafanaUrl")] + public Input? GrafanaUrl { get; set; } + + /// + /// The Observability instance ID. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Specifies if the instance can be updated. + /// + [Input("isUpdatable")] + public Input? IsUpdatable { get; set; } + + [Input("jaegerTracesUrl")] + public Input? JaegerTracesUrl { get; set; } + + [Input("jaegerUiUrl")] + public Input? JaegerUiUrl { get; set; } + + /// + /// Specifies URL for pushing logs. + /// + [Input("logsPushUrl")] + public Input? LogsPushUrl { get; set; } + + /// + /// Specifies Logs URL. + /// + [Input("logsUrl")] + public Input? LogsUrl { get; set; } + + /// + /// Specifies URL for pushing metrics. + /// + [Input("metricsPushUrl")] + public Input? MetricsPushUrl { get; set; } + + /// + /// Specifies for how many days the raw metrics are kept. + /// + [Input("metricsRetentionDays")] + public Input? MetricsRetentionDays { get; set; } + + /// + /// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + /// + [Input("metricsRetentionDays1hDownsampling")] + public Input? MetricsRetentionDays1hDownsampling { get; set; } + + /// + /// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + /// + [Input("metricsRetentionDays5mDownsampling")] + public Input? MetricsRetentionDays5mDownsampling { get; set; } + + /// + /// Specifies metrics URL. + /// + [Input("metricsUrl")] + public Input? MetricsUrl { get; set; } + + /// + /// The name of the Observability instance. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("otlpTracesUrl")] + public Input? OtlpTracesUrl { get; set; } + + [Input("parameters")] + private InputMap? _parameters; + + /// + /// Additional parameters. + /// + public InputMap Parameters + { + get => _parameters ?? (_parameters = new InputMap()); + set => _parameters = value; + } + + /// + /// The Observability plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Specifies Targets URL. + /// + [Input("targetsUrl")] + public Input? TargetsUrl { get; set; } + + [Input("zipkinSpansUrl")] + public Input? ZipkinSpansUrl { get; set; } + + public ObservabilityInstanceState() + { + } + public static new ObservabilityInstanceState Empty => new ObservabilityInstanceState(); + } +} diff --git a/sdk/dotnet/ObservabilityLogalertgroup.cs b/sdk/dotnet/ObservabilityLogalertgroup.cs new file mode 100644 index 0000000..1a84fba --- /dev/null +++ b/sdk/dotnet/ObservabilityLogalertgroup.cs @@ -0,0 +1,182 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup")] + public partial class ObservabilityLogalertgroup : global::Pulumi.CustomResource + { + /// + /// Observability instance ID to which the log alert group is associated. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Output("interval")] + public Output Interval { get; private set; } = null!; + + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the log alert group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Rules for the log alert group + /// + [Output("rules")] + public Output> Rules { get; private set; } = null!; + + + /// + /// Create a ObservabilityLogalertgroup 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 ObservabilityLogalertgroup(string name, ObservabilityLogalertgroupArgs args, CustomResourceOptions? options = null) + : base("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup", name, args ?? new ObservabilityLogalertgroupArgs(), MakeResourceOptions(options, "")) + { + } + + private ObservabilityLogalertgroup(string name, Input id, ObservabilityLogalertgroupState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ObservabilityLogalertgroup 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 ObservabilityLogalertgroup Get(string name, Input id, ObservabilityLogalertgroupState? state = null, CustomResourceOptions? options = null) + { + return new ObservabilityLogalertgroup(name, id, state, options); + } + } + + public sealed class ObservabilityLogalertgroupArgs : global::Pulumi.ResourceArgs + { + /// + /// Observability instance ID to which the log alert group is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the log alert group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("rules", required: true)] + private InputList? _rules; + + /// + /// Rules for the log alert group + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public ObservabilityLogalertgroupArgs() + { + } + public static new ObservabilityLogalertgroupArgs Empty => new ObservabilityLogalertgroupArgs(); + } + + public sealed class ObservabilityLogalertgroupState : global::Pulumi.ResourceArgs + { + /// + /// Observability instance ID to which the log alert group is associated. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + /// + [Input("interval")] + public Input? Interval { get; set; } + + /// + /// The name of the log alert group. Is the identifier and must be unique in the group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the log alert group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("rules")] + private InputList? _rules; + + /// + /// Rules for the log alert group + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public ObservabilityLogalertgroupState() + { + } + public static new ObservabilityLogalertgroupState Empty => new ObservabilityLogalertgroupState(); + } +} diff --git a/sdk/dotnet/ObservabilityScrapeconfig.cs b/sdk/dotnet/ObservabilityScrapeconfig.cs new file mode 100644 index 0000000..28667c4 --- /dev/null +++ b/sdk/dotnet/ObservabilityScrapeconfig.cs @@ -0,0 +1,290 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Observability scrape config resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig")] + public partial class ObservabilityScrapeconfig : global::Pulumi.CustomResource + { + /// + /// A basic authentication block. + /// + [Output("basicAuth")] + public Output BasicAuth { get; private set; } = null!; + + /// + /// Observability instance ID to which the scraping job is associated. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Specifies the job scraping url path. E.g. `/metrics`. + /// + [Output("metricsPath")] + public Output MetricsPath { get; private set; } = null!; + + /// + /// Specifies the name of the scraping job. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the scraping job is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// A SAML2 configuration block. + /// + [Output("saml2")] + public Output Saml2 { get; private set; } = null!; + + /// + /// Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + /// + [Output("sampleLimit")] + public Output SampleLimit { get; private set; } = null!; + + /// + /// Specifies the http scheme. Defaults to `https`. + /// + [Output("scheme")] + public Output Scheme { get; private set; } = null!; + + /// + /// Specifies the scrape interval as duration string. Defaults to `5m`. + /// + [Output("scrapeInterval")] + public Output ScrapeInterval { get; private set; } = null!; + + /// + /// Specifies the scrape timeout as duration string. Defaults to `2m`. + /// + [Output("scrapeTimeout")] + public Output ScrapeTimeout { get; private set; } = null!; + + /// + /// The targets list (specified by the static config). + /// + [Output("targets")] + public Output> Targets { get; private set; } = null!; + + + /// + /// Create a ObservabilityScrapeconfig 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 ObservabilityScrapeconfig(string name, ObservabilityScrapeconfigArgs args, CustomResourceOptions? options = null) + : base("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig", name, args ?? new ObservabilityScrapeconfigArgs(), MakeResourceOptions(options, "")) + { + } + + private ObservabilityScrapeconfig(string name, Input id, ObservabilityScrapeconfigState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ObservabilityScrapeconfig 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 ObservabilityScrapeconfig Get(string name, Input id, ObservabilityScrapeconfigState? state = null, CustomResourceOptions? options = null) + { + return new ObservabilityScrapeconfig(name, id, state, options); + } + } + + public sealed class ObservabilityScrapeconfigArgs : global::Pulumi.ResourceArgs + { + /// + /// A basic authentication block. + /// + [Input("basicAuth")] + public Input? BasicAuth { get; set; } + + /// + /// Observability instance ID to which the scraping job is associated. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// Specifies the job scraping url path. E.g. `/metrics`. + /// + [Input("metricsPath", required: true)] + public Input MetricsPath { get; set; } = null!; + + /// + /// Specifies the name of the scraping job. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the scraping job is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// A SAML2 configuration block. + /// + [Input("saml2")] + public Input? Saml2 { get; set; } + + /// + /// Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + /// + [Input("sampleLimit")] + public Input? SampleLimit { get; set; } + + /// + /// Specifies the http scheme. Defaults to `https`. + /// + [Input("scheme")] + public Input? Scheme { get; set; } + + /// + /// Specifies the scrape interval as duration string. Defaults to `5m`. + /// + [Input("scrapeInterval")] + public Input? ScrapeInterval { get; set; } + + /// + /// Specifies the scrape timeout as duration string. Defaults to `2m`. + /// + [Input("scrapeTimeout")] + public Input? ScrapeTimeout { get; set; } + + [Input("targets", required: true)] + private InputList? _targets; + + /// + /// The targets list (specified by the static config). + /// + public InputList Targets + { + get => _targets ?? (_targets = new InputList()); + set => _targets = value; + } + + public ObservabilityScrapeconfigArgs() + { + } + public static new ObservabilityScrapeconfigArgs Empty => new ObservabilityScrapeconfigArgs(); + } + + public sealed class ObservabilityScrapeconfigState : global::Pulumi.ResourceArgs + { + /// + /// A basic authentication block. + /// + [Input("basicAuth")] + public Input? BasicAuth { get; set; } + + /// + /// Observability instance ID to which the scraping job is associated. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Specifies the job scraping url path. E.g. `/metrics`. + /// + [Input("metricsPath")] + public Input? MetricsPath { get; set; } + + /// + /// Specifies the name of the scraping job. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the scraping job is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// A SAML2 configuration block. + /// + [Input("saml2")] + public Input? Saml2 { get; set; } + + /// + /// Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + /// + [Input("sampleLimit")] + public Input? SampleLimit { get; set; } + + /// + /// Specifies the http scheme. Defaults to `https`. + /// + [Input("scheme")] + public Input? Scheme { get; set; } + + /// + /// Specifies the scrape interval as duration string. Defaults to `5m`. + /// + [Input("scrapeInterval")] + public Input? ScrapeInterval { get; set; } + + /// + /// Specifies the scrape timeout as duration string. Defaults to `2m`. + /// + [Input("scrapeTimeout")] + public Input? ScrapeTimeout { get; set; } + + [Input("targets")] + private InputList? _targets; + + /// + /// The targets list (specified by the static config). + /// + public InputList Targets + { + get => _targets ?? (_targets = new InputList()); + set => _targets = value; + } + + public ObservabilityScrapeconfigState() + { + } + public static new ObservabilityScrapeconfigState Empty => new ObservabilityScrapeconfigState(); + } +} diff --git a/sdk/dotnet/OpensearchCredential.cs b/sdk/dotnet/OpensearchCredential.cs new file mode 100644 index 0000000..d00e610 --- /dev/null +++ b/sdk/dotnet/OpensearchCredential.cs @@ -0,0 +1,198 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// OpenSearch credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/opensearchCredential:OpensearchCredential")] + public partial class OpensearchCredential : global::Pulumi.CustomResource + { + /// + /// The credential's ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + [Output("hosts")] + public Output> Hosts { get; private set; } = null!; + + /// + /// ID of the OpenSearch instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("scheme")] + public Output Scheme { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a OpensearchCredential 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 OpensearchCredential(string name, OpensearchCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/opensearchCredential:OpensearchCredential", name, args ?? new OpensearchCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private OpensearchCredential(string name, Input id, OpensearchCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/opensearchCredential:OpensearchCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 OpensearchCredential 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 OpensearchCredential Get(string name, Input id, OpensearchCredentialState? state = null, CustomResourceOptions? options = null) + { + return new OpensearchCredential(name, id, state, options); + } + } + + public sealed class OpensearchCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public OpensearchCredentialArgs() + { + } + public static new OpensearchCredentialArgs Empty => new OpensearchCredentialArgs(); + } + + public sealed class OpensearchCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + [Input("hosts")] + private InputList? _hosts; + public InputList Hosts + { + get => _hosts ?? (_hosts = new InputList()); + set => _hosts = value; + } + + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("scheme")] + public Input? Scheme { get; set; } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("username")] + public Input? Username { get; set; } + + public OpensearchCredentialState() + { + } + public static new OpensearchCredentialState Empty => new OpensearchCredentialState(); + } +} diff --git a/sdk/dotnet/OpensearchInstance.cs b/sdk/dotnet/OpensearchInstance.cs new file mode 100644 index 0000000..15ba7fa --- /dev/null +++ b/sdk/dotnet/OpensearchInstance.cs @@ -0,0 +1,215 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// OpenSearch instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/opensearchInstance:OpensearchInstance")] + public partial class OpensearchInstance : global::Pulumi.CustomResource + { + [Output("cfGuid")] + public Output CfGuid { get; private set; } = null!; + + [Output("cfOrganizationGuid")] + public Output CfOrganizationGuid { get; private set; } = null!; + + [Output("cfSpaceGuid")] + public Output CfSpaceGuid { get; private set; } = null!; + + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + [Output("imageUrl")] + public Output ImageUrl { get; private set; } = null!; + + /// + /// ID of the OpenSearch instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("parameters")] + public Output Parameters { get; private set; } = null!; + + /// + /// The selected plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// The selected plan name. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The service version. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a OpensearchInstance 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 OpensearchInstance(string name, OpensearchInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/opensearchInstance:OpensearchInstance", name, args ?? new OpensearchInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private OpensearchInstance(string name, Input id, OpensearchInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/opensearchInstance:OpensearchInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 OpensearchInstance 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 OpensearchInstance Get(string name, Input id, OpensearchInstanceState? state = null, CustomResourceOptions? options = null) + { + return new OpensearchInstance(name, id, state, options); + } + } + + public sealed class OpensearchInstanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The service version. + /// + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public OpensearchInstanceArgs() + { + } + public static new OpensearchInstanceArgs Empty => new OpensearchInstanceArgs(); + } + + public sealed class OpensearchInstanceState : global::Pulumi.ResourceArgs + { + [Input("cfGuid")] + public Input? CfGuid { get; set; } + + [Input("cfOrganizationGuid")] + public Input? CfOrganizationGuid { get; set; } + + [Input("cfSpaceGuid")] + public Input? CfSpaceGuid { get; set; } + + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("imageUrl")] + public Input? ImageUrl { get; set; } + + /// + /// ID of the OpenSearch instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The service version. + /// + [Input("version")] + public Input? Version { get; set; } + + public OpensearchInstanceState() + { + } + public static new OpensearchInstanceState Empty => new OpensearchInstanceState(); + } +} diff --git a/sdk/dotnet/Outputs/CdnDistributionConfig.cs b/sdk/dotnet/Outputs/CdnDistributionConfig.cs new file mode 100644 index 0000000..4c94df0 --- /dev/null +++ b/sdk/dotnet/Outputs/CdnDistributionConfig.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class CdnDistributionConfig + { + /// + /// The configured backend for the distribution + /// + public readonly Outputs.CdnDistributionConfigBackend Backend; + /// + /// The configured regions where content will be hosted + /// + public readonly ImmutableArray Regions; + + [OutputConstructor] + private CdnDistributionConfig( + Outputs.CdnDistributionConfigBackend backend, + + ImmutableArray regions) + { + Backend = backend; + Regions = regions; + } + } +} diff --git a/sdk/dotnet/Outputs/CdnDistributionConfigBackend.cs b/sdk/dotnet/Outputs/CdnDistributionConfigBackend.cs new file mode 100644 index 0000000..f26b359 --- /dev/null +++ b/sdk/dotnet/Outputs/CdnDistributionConfigBackend.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class CdnDistributionConfigBackend + { + /// + /// The configured origin request headers for the backend + /// + public readonly ImmutableDictionary? OriginRequestHeaders; + /// + /// The configured backend type for the distribution + /// + public readonly string OriginUrl; + /// + /// The configured backend type. Supported values are: `http`. + /// + public readonly string Type; + + [OutputConstructor] + private CdnDistributionConfigBackend( + ImmutableDictionary? originRequestHeaders, + + string originUrl, + + string type) + { + OriginRequestHeaders = originRequestHeaders; + OriginUrl = originUrl; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/CdnDistributionDomain.cs b/sdk/dotnet/Outputs/CdnDistributionDomain.cs new file mode 100644 index 0000000..54165ce --- /dev/null +++ b/sdk/dotnet/Outputs/CdnDistributionDomain.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class CdnDistributionDomain + { + /// + /// List of domain errors + /// + public readonly ImmutableArray Errors; + /// + /// The name of the domain + /// + public readonly string? Name; + /// + /// The status of the domain + /// + public readonly string? Status; + /// + /// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + /// + public readonly string? Type; + + [OutputConstructor] + private CdnDistributionDomain( + ImmutableArray errors, + + string? name, + + string? status, + + string? type) + { + Errors = errors; + Name = name; + Status = status; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/GetCdnDistributionConfigBackendResult.cs b/sdk/dotnet/Outputs/GetCdnDistributionConfigBackendResult.cs new file mode 100644 index 0000000..61ee655 --- /dev/null +++ b/sdk/dotnet/Outputs/GetCdnDistributionConfigBackendResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetCdnDistributionConfigBackendResult + { + /// + /// The configured origin request headers for the backend + /// + public readonly ImmutableDictionary OriginRequestHeaders; + /// + /// The configured backend type for the distribution + /// + public readonly string OriginUrl; + /// + /// The configured backend type. Supported values are: `http`. + /// + public readonly string Type; + + [OutputConstructor] + private GetCdnDistributionConfigBackendResult( + ImmutableDictionary originRequestHeaders, + + string originUrl, + + string type) + { + OriginRequestHeaders = originRequestHeaders; + OriginUrl = originUrl; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/GetCdnDistributionConfigResult.cs b/sdk/dotnet/Outputs/GetCdnDistributionConfigResult.cs new file mode 100644 index 0000000..62bbe56 --- /dev/null +++ b/sdk/dotnet/Outputs/GetCdnDistributionConfigResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetCdnDistributionConfigResult + { + /// + /// The configured backend for the distribution + /// + public readonly Outputs.GetCdnDistributionConfigBackendResult Backend; + /// + /// The configured regions where content will be hosted + /// + public readonly ImmutableArray Regions; + + [OutputConstructor] + private GetCdnDistributionConfigResult( + Outputs.GetCdnDistributionConfigBackendResult backend, + + ImmutableArray regions) + { + Backend = backend; + Regions = regions; + } + } +} diff --git a/sdk/dotnet/Outputs/GetCdnDistributionDomainResult.cs b/sdk/dotnet/Outputs/GetCdnDistributionDomainResult.cs new file mode 100644 index 0000000..77b56b8 --- /dev/null +++ b/sdk/dotnet/Outputs/GetCdnDistributionDomainResult.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetCdnDistributionDomainResult + { + /// + /// List of domain errors + /// + public readonly ImmutableArray Errors; + /// + /// The name of the domain + /// + public readonly string Name; + /// + /// The status of the domain + /// + public readonly string Status; + /// + /// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + /// + public readonly string Type; + + [OutputConstructor] + private GetCdnDistributionDomainResult( + ImmutableArray errors, + + string name, + + string status, + + string type) + { + Errors = errors; + Name = name; + Status = status; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/GetImageChecksumResult.cs b/sdk/dotnet/Outputs/GetImageChecksumResult.cs new file mode 100644 index 0000000..52d7ef0 --- /dev/null +++ b/sdk/dotnet/Outputs/GetImageChecksumResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetImageChecksumResult + { + /// + /// Algorithm for the checksum of the image data. + /// + public readonly string Algorithm; + /// + /// Hexdigest of the checksum of the image data. + /// + public readonly string Digest; + + [OutputConstructor] + private GetImageChecksumResult( + string algorithm, + + string digest) + { + Algorithm = algorithm; + Digest = digest; + } + } +} diff --git a/sdk/dotnet/Outputs/GetImageConfigResult.cs b/sdk/dotnet/Outputs/GetImageConfigResult.cs new file mode 100644 index 0000000..81db180 --- /dev/null +++ b/sdk/dotnet/Outputs/GetImageConfigResult.cs @@ -0,0 +1,112 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetImageConfigResult + { + /// + /// Enables the BIOS bootmenu. + /// + public readonly bool BootMenu; + /// + /// Sets CDROM bus controller type. + /// + public readonly string CdromBus; + /// + /// Sets Disk bus controller type. + /// + public readonly string DiskBus; + /// + /// Sets virtual network interface model. + /// + public readonly string NicModel; + /// + /// Enables operating system specific optimizations. + /// + public readonly string OperatingSystem; + /// + /// Operating system distribution. + /// + public readonly string OperatingSystemDistro; + /// + /// Version of the operating system. + /// + public readonly string OperatingSystemVersion; + /// + /// Sets the device bus when the image is used as a rescue image. + /// + public readonly string RescueBus; + /// + /// Sets the device when the image is used as a rescue image. + /// + public readonly string RescueDevice; + /// + /// Enables Secure Boot. + /// + public readonly bool SecureBoot; + /// + /// Enables UEFI boot. + /// + public readonly bool Uefi; + /// + /// Sets Graphic device model. + /// + public readonly string VideoModel; + /// + /// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + /// + public readonly bool VirtioScsi; + + [OutputConstructor] + private GetImageConfigResult( + bool bootMenu, + + string cdromBus, + + string diskBus, + + string nicModel, + + string operatingSystem, + + string operatingSystemDistro, + + string operatingSystemVersion, + + string rescueBus, + + string rescueDevice, + + bool secureBoot, + + bool uefi, + + string videoModel, + + bool virtioScsi) + { + BootMenu = bootMenu; + CdromBus = cdromBus; + DiskBus = diskBus; + NicModel = nicModel; + OperatingSystem = operatingSystem; + OperatingSystemDistro = operatingSystemDistro; + OperatingSystemVersion = operatingSystemVersion; + RescueBus = rescueBus; + RescueDevice = rescueDevice; + SecureBoot = secureBoot; + Uefi = uefi; + VideoModel = videoModel; + VirtioScsi = virtioScsi; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerListenerResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerListenerResult.cs new file mode 100644 index 0000000..b12de19 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerListenerResult.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerListenerResult + { + public readonly string DisplayName; + /// + /// Port number where we listen for traffic. + /// + public readonly int Port; + /// + /// Protocol is the highest network protocol we understand to load balance. + /// + public readonly string Protocol; + /// + /// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + /// + public readonly ImmutableArray ServerNameIndicators; + /// + /// Reference target pool by target pool name. + /// + public readonly string TargetPool; + + [OutputConstructor] + private GetLoadbalancerListenerResult( + string displayName, + + int port, + + string protocol, + + ImmutableArray serverNameIndicators, + + string targetPool) + { + DisplayName = displayName; + Port = port; + Protocol = protocol; + ServerNameIndicators = serverNameIndicators; + TargetPool = targetPool; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerListenerServerNameIndicatorResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerListenerServerNameIndicatorResult.cs new file mode 100644 index 0000000..54f634d --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerListenerServerNameIndicatorResult.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerListenerServerNameIndicatorResult + { + /// + /// A domain name to match in order to pass TLS traffic to the target pool in the current listener + /// + public readonly string? Name; + + [OutputConstructor] + private GetLoadbalancerListenerServerNameIndicatorResult(string? name) + { + Name = name; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerNetworkResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerNetworkResult.cs new file mode 100644 index 0000000..e855b7f --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerNetworkResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerNetworkResult + { + /// + /// Openstack network ID. + /// + public readonly string NetworkId; + /// + /// The role defines how the load balancer is using the network. + /// + public readonly string Role; + + [OutputConstructor] + private GetLoadbalancerNetworkResult( + string networkId, + + string role) + { + NetworkId = networkId; + Role = role; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityLogsResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityLogsResult.cs new file mode 100644 index 0000000..0b9b9e0 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityLogsResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerOptionsObservabilityLogsResult + { + /// + /// Credentials reference for logs. + /// + public readonly string CredentialsRef; + /// + /// Credentials reference for logs. + /// + public readonly string PushUrl; + + [OutputConstructor] + private GetLoadbalancerOptionsObservabilityLogsResult( + string credentialsRef, + + string pushUrl) + { + CredentialsRef = credentialsRef; + PushUrl = pushUrl; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityMetricsResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityMetricsResult.cs new file mode 100644 index 0000000..d8e45f8 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityMetricsResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerOptionsObservabilityMetricsResult + { + /// + /// Credentials reference for metrics. + /// + public readonly string CredentialsRef; + /// + /// Credentials reference for metrics. + /// + public readonly string PushUrl; + + [OutputConstructor] + private GetLoadbalancerOptionsObservabilityMetricsResult( + string credentialsRef, + + string pushUrl) + { + CredentialsRef = credentialsRef; + PushUrl = pushUrl; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityResult.cs new file mode 100644 index 0000000..855a4d9 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerOptionsObservabilityResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerOptionsObservabilityResult + { + /// + /// Observability logs configuration. + /// + public readonly Outputs.GetLoadbalancerOptionsObservabilityLogsResult Logs; + /// + /// Observability metrics configuration. + /// + public readonly Outputs.GetLoadbalancerOptionsObservabilityMetricsResult Metrics; + + [OutputConstructor] + private GetLoadbalancerOptionsObservabilityResult( + Outputs.GetLoadbalancerOptionsObservabilityLogsResult logs, + + Outputs.GetLoadbalancerOptionsObservabilityMetricsResult metrics) + { + Logs = logs; + Metrics = metrics; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerOptionsResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerOptionsResult.cs new file mode 100644 index 0000000..970a127 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerOptionsResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerOptionsResult + { + /// + /// Load Balancer is accessible only from an IP address in this range. + /// + public readonly ImmutableArray Acls; + /// + /// We offer Load Balancer metrics observability via ARGUS or external solutions. + /// + public readonly Outputs.GetLoadbalancerOptionsObservabilityResult Observability; + /// + /// If true, Load Balancer is accessible only via a private network IP address. + /// + public readonly bool PrivateNetworkOnly; + + [OutputConstructor] + private GetLoadbalancerOptionsResult( + ImmutableArray acls, + + Outputs.GetLoadbalancerOptionsObservabilityResult observability, + + bool privateNetworkOnly) + { + Acls = acls; + Observability = observability; + PrivateNetworkOnly = privateNetworkOnly; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolActiveHealthCheckResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolActiveHealthCheckResult.cs new file mode 100644 index 0000000..22a5104 --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolActiveHealthCheckResult.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerTargetPoolActiveHealthCheckResult + { + /// + /// Healthy threshold of the health checking. + /// + public readonly int HealthyThreshold; + /// + /// Interval duration of health checking in seconds. + /// + public readonly string Interval; + /// + /// Interval duration threshold of the health checking in seconds. + /// + public readonly string IntervalJitter; + /// + /// Active health checking timeout duration in seconds. + /// + public readonly string Timeout; + /// + /// Unhealthy threshold of the health checking. + /// + public readonly int UnhealthyThreshold; + + [OutputConstructor] + private GetLoadbalancerTargetPoolActiveHealthCheckResult( + int healthyThreshold, + + string interval, + + string intervalJitter, + + string timeout, + + int unhealthyThreshold) + { + HealthyThreshold = healthyThreshold; + Interval = interval; + IntervalJitter = intervalJitter; + Timeout = timeout; + UnhealthyThreshold = unhealthyThreshold; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolResult.cs new file mode 100644 index 0000000..6afea0b --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolResult.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerTargetPoolResult + { + public readonly Outputs.GetLoadbalancerTargetPoolActiveHealthCheckResult ActiveHealthCheck; + /// + /// Target pool name. + /// + public readonly string Name; + /// + /// Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + /// + public readonly Outputs.GetLoadbalancerTargetPoolSessionPersistenceResult? SessionPersistence; + /// + /// Identical port number where each target listens for traffic. + /// + public readonly int TargetPort; + /// + /// List of all targets which will be used in the pool. Limited to 1000. + /// + public readonly ImmutableArray Targets; + + [OutputConstructor] + private GetLoadbalancerTargetPoolResult( + Outputs.GetLoadbalancerTargetPoolActiveHealthCheckResult activeHealthCheck, + + string name, + + Outputs.GetLoadbalancerTargetPoolSessionPersistenceResult? sessionPersistence, + + int targetPort, + + ImmutableArray targets) + { + ActiveHealthCheck = activeHealthCheck; + Name = name; + SessionPersistence = sessionPersistence; + TargetPort = targetPort; + Targets = targets; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolSessionPersistenceResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolSessionPersistenceResult.cs new file mode 100644 index 0000000..1235cdd --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolSessionPersistenceResult.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerTargetPoolSessionPersistenceResult + { + /// + /// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + /// + public readonly bool? UseSourceIpAddress; + + [OutputConstructor] + private GetLoadbalancerTargetPoolSessionPersistenceResult(bool? useSourceIpAddress) + { + UseSourceIpAddress = useSourceIpAddress; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolTargetResult.cs b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolTargetResult.cs new file mode 100644 index 0000000..038ec0a --- /dev/null +++ b/sdk/dotnet/Outputs/GetLoadbalancerTargetPoolTargetResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLoadbalancerTargetPoolTargetResult + { + /// + /// Target display name + /// + public readonly string DisplayName; + /// + /// Target IP + /// + public readonly string Ip; + + [OutputConstructor] + private GetLoadbalancerTargetPoolTargetResult( + string displayName, + + string ip) + { + DisplayName = displayName; + Ip = ip; + } + } +} diff --git a/sdk/dotnet/Outputs/GetLogmeInstanceParametersResult.cs b/sdk/dotnet/Outputs/GetLogmeInstanceParametersResult.cs new file mode 100644 index 0000000..d351c7c --- /dev/null +++ b/sdk/dotnet/Outputs/GetLogmeInstanceParametersResult.cs @@ -0,0 +1,145 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetLogmeInstanceParametersResult + { + /// + /// Enable monitoring. + /// + public readonly bool EnableMonitoring; + public readonly int FluentdTcp; + public readonly int FluentdTls; + public readonly string FluentdTlsCiphers; + public readonly string FluentdTlsMaxVersion; + public readonly string FluentdTlsMinVersion; + public readonly string FluentdTlsVersion; + public readonly int FluentdUdp; + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + public readonly string Graphite; + /// + /// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + /// + public readonly string IsmDeletionAfter; + public readonly double IsmJitter; + /// + /// Jitter of the execution time. + /// + public readonly int IsmJobInterval; + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + public readonly int JavaHeapspace; + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + public readonly int JavaMaxmetaspace; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + public readonly int MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + public readonly string MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string MonitoringInstanceId; + public readonly ImmutableArray OpensearchTlsCiphers; + public readonly ImmutableArray OpensearchTlsProtocols; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + + [OutputConstructor] + private GetLogmeInstanceParametersResult( + bool enableMonitoring, + + int fluentdTcp, + + int fluentdTls, + + string fluentdTlsCiphers, + + string fluentdTlsMaxVersion, + + string fluentdTlsMinVersion, + + string fluentdTlsVersion, + + int fluentdUdp, + + string graphite, + + string ismDeletionAfter, + + double ismJitter, + + int ismJobInterval, + + int javaHeapspace, + + int javaMaxmetaspace, + + int maxDiskThreshold, + + int metricsFrequency, + + string metricsPrefix, + + string monitoringInstanceId, + + ImmutableArray opensearchTlsCiphers, + + ImmutableArray opensearchTlsProtocols, + + string sgwAcl, + + ImmutableArray syslogs) + { + EnableMonitoring = enableMonitoring; + FluentdTcp = fluentdTcp; + FluentdTls = fluentdTls; + FluentdTlsCiphers = fluentdTlsCiphers; + FluentdTlsMaxVersion = fluentdTlsMaxVersion; + FluentdTlsMinVersion = fluentdTlsMinVersion; + FluentdTlsVersion = fluentdTlsVersion; + FluentdUdp = fluentdUdp; + Graphite = graphite; + IsmDeletionAfter = ismDeletionAfter; + IsmJitter = ismJitter; + IsmJobInterval = ismJobInterval; + JavaHeapspace = javaHeapspace; + JavaMaxmetaspace = javaMaxmetaspace; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + OpensearchTlsCiphers = opensearchTlsCiphers; + OpensearchTlsProtocols = opensearchTlsProtocols; + SgwAcl = sgwAcl; + Syslogs = syslogs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetMariadbInstanceParametersResult.cs b/sdk/dotnet/Outputs/GetMariadbInstanceParametersResult.cs new file mode 100644 index 0000000..8e2c139 --- /dev/null +++ b/sdk/dotnet/Outputs/GetMariadbInstanceParametersResult.cs @@ -0,0 +1,74 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetMariadbInstanceParametersResult + { + /// + /// Enable monitoring. + /// + public readonly bool EnableMonitoring; + public readonly string Graphite; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string MonitoringInstanceId; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + + [OutputConstructor] + private GetMariadbInstanceParametersResult( + bool enableMonitoring, + + string graphite, + + int maxDiskThreshold, + + int metricsFrequency, + + string metricsPrefix, + + string monitoringInstanceId, + + string sgwAcl, + + ImmutableArray syslogs) + { + EnableMonitoring = enableMonitoring; + Graphite = graphite; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + SgwAcl = sgwAcl; + Syslogs = syslogs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetMongodbflexInstanceFlavorResult.cs b/sdk/dotnet/Outputs/GetMongodbflexInstanceFlavorResult.cs new file mode 100644 index 0000000..9e5a722 --- /dev/null +++ b/sdk/dotnet/Outputs/GetMongodbflexInstanceFlavorResult.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetMongodbflexInstanceFlavorResult + { + public readonly int Cpu; + public readonly string Description; + public readonly string Id; + public readonly int Ram; + + [OutputConstructor] + private GetMongodbflexInstanceFlavorResult( + int cpu, + + string description, + + string id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/GetMongodbflexInstanceOptionsResult.cs b/sdk/dotnet/Outputs/GetMongodbflexInstanceOptionsResult.cs new file mode 100644 index 0000000..336c7c3 --- /dev/null +++ b/sdk/dotnet/Outputs/GetMongodbflexInstanceOptionsResult.cs @@ -0,0 +1,63 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetMongodbflexInstanceOptionsResult + { + /// + /// The number of days that daily backups will be retained. + /// + public readonly int DailySnapshotRetentionDays; + /// + /// The number of months that monthly backups will be retained. + /// + public readonly int MonthlySnapshotRetentionMonths; + /// + /// The number of hours back in time the point-in-time recovery feature will be able to recover. + /// + public readonly int PointInTimeWindowHours; + /// + /// The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + /// + public readonly int SnapshotRetentionDays; + /// + /// Type of the MongoDB Flex instance. + /// + public readonly string Type; + /// + /// The number of weeks that weekly backups will be retained. + /// + public readonly int WeeklySnapshotRetentionWeeks; + + [OutputConstructor] + private GetMongodbflexInstanceOptionsResult( + int dailySnapshotRetentionDays, + + int monthlySnapshotRetentionMonths, + + int pointInTimeWindowHours, + + int snapshotRetentionDays, + + string type, + + int weeklySnapshotRetentionWeeks) + { + DailySnapshotRetentionDays = dailySnapshotRetentionDays; + MonthlySnapshotRetentionMonths = monthlySnapshotRetentionMonths; + PointInTimeWindowHours = pointInTimeWindowHours; + SnapshotRetentionDays = snapshotRetentionDays; + Type = type; + WeeklySnapshotRetentionWeeks = weeklySnapshotRetentionWeeks; + } + } +} diff --git a/sdk/dotnet/Outputs/GetMongodbflexInstanceStorageResult.cs b/sdk/dotnet/Outputs/GetMongodbflexInstanceStorageResult.cs new file mode 100644 index 0000000..626301c --- /dev/null +++ b/sdk/dotnet/Outputs/GetMongodbflexInstanceStorageResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetMongodbflexInstanceStorageResult + { + public readonly string Class; + public readonly int Size; + + [OutputConstructor] + private GetMongodbflexInstanceStorageResult( + string @class, + + int size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/GetNetworkAreaNetworkRangeResult.cs b/sdk/dotnet/Outputs/GetNetworkAreaNetworkRangeResult.cs new file mode 100644 index 0000000..eeabf35 --- /dev/null +++ b/sdk/dotnet/Outputs/GetNetworkAreaNetworkRangeResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetNetworkAreaNetworkRangeResult + { + public readonly string NetworkRangeId; + public readonly string Prefix; + + [OutputConstructor] + private GetNetworkAreaNetworkRangeResult( + string networkRangeId, + + string prefix) + { + NetworkRangeId = networkRangeId; + Prefix = prefix; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityAlertgroupRuleResult.cs b/sdk/dotnet/Outputs/GetObservabilityAlertgroupRuleResult.cs new file mode 100644 index 0000000..5f04756 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityAlertgroupRuleResult.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityAlertgroupRuleResult + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + public readonly string Alert; + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public readonly ImmutableDictionary Annotations; + /// + /// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + public readonly string Expression; + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + public readonly string For; + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public readonly ImmutableDictionary Labels; + + [OutputConstructor] + private GetObservabilityAlertgroupRuleResult( + string alert, + + ImmutableDictionary annotations, + + string expression, + + string @for, + + ImmutableDictionary labels) + { + Alert = alert; + Annotations = annotations; + Expression = expression; + For = @for; + Labels = labels; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigGlobalResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigGlobalResult.cs new file mode 100644 index 0000000..d21ccf6 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigGlobalResult.cs @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigGlobalResult + { + /// + /// The API key for OpsGenie. + /// + public readonly string OpsgenieApiKey; + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + public readonly string OpsgenieApiUrl; + /// + /// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + /// + public readonly string ResolveTimeout; + /// + /// SMTP authentication information. Must be a valid email address + /// + public readonly string SmtpAuthIdentity; + /// + /// SMTP Auth using LOGIN and PLAIN. + /// + public readonly string SmtpAuthPassword; + /// + /// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + /// + public readonly string SmtpAuthUsername; + /// + /// The default SMTP From header field. Must be a valid email address + /// + public readonly string SmtpFrom; + /// + /// The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + /// + public readonly string SmtpSmartHost; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigGlobalResult( + string opsgenieApiKey, + + string opsgenieApiUrl, + + string resolveTimeout, + + string smtpAuthIdentity, + + string smtpAuthPassword, + + string smtpAuthUsername, + + string smtpFrom, + + string smtpSmartHost) + { + OpsgenieApiKey = opsgenieApiKey; + OpsgenieApiUrl = opsgenieApiUrl; + ResolveTimeout = resolveTimeout; + SmtpAuthIdentity = smtpAuthIdentity; + SmtpAuthPassword = smtpAuthPassword; + SmtpAuthUsername = smtpAuthUsername; + SmtpFrom = smtpFrom; + SmtpSmartHost = smtpSmartHost; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverEmailConfigResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverEmailConfigResult.cs new file mode 100644 index 0000000..463effa --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverEmailConfigResult.cs @@ -0,0 +1,63 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigReceiverEmailConfigResult + { + /// + /// SMTP authentication information. Must be a valid email address + /// + public readonly string AuthIdentity; + /// + /// SMTP authentication password. + /// + public readonly string AuthPassword; + /// + /// SMTP authentication username. + /// + public readonly string AuthUsername; + /// + /// The sender email address. Must be a valid email address + /// + public readonly string From; + /// + /// The SMTP host through which emails are sent. + /// + public readonly string SmartHost; + /// + /// The email address to send notifications to. Must be a valid email address + /// + public readonly string To; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigReceiverEmailConfigResult( + string authIdentity, + + string authPassword, + + string authUsername, + + string from, + + string smartHost, + + string to) + { + AuthIdentity = authIdentity; + AuthPassword = authPassword; + AuthUsername = authUsername; + From = from; + SmartHost = smartHost; + To = to; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult.cs new file mode 100644 index 0000000..81db586 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult + { + /// + /// The API key for OpsGenie. + /// + public readonly string ApiKey; + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + public readonly string ApiUrl; + /// + /// Comma separated list of tags attached to the notifications. + /// + public readonly string Tags; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult( + string apiKey, + + string apiUrl, + + string tags) + { + ApiKey = apiKey; + ApiUrl = apiUrl; + Tags = tags; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverResult.cs new file mode 100644 index 0000000..b7c6811 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverResult.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigReceiverResult + { + /// + /// List of email configurations. + /// + public readonly ImmutableArray EmailConfigs; + /// + /// Name of the receiver. + /// + public readonly string Name; + /// + /// List of OpsGenie configurations. + /// + public readonly ImmutableArray OpsgenieConfigs; + /// + /// List of Webhooks configurations. + /// + public readonly ImmutableArray WebhooksConfigs; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigReceiverResult( + ImmutableArray emailConfigs, + + string name, + + ImmutableArray opsgenieConfigs, + + ImmutableArray webhooksConfigs) + { + EmailConfigs = emailConfigs; + Name = name; + OpsgenieConfigs = opsgenieConfigs; + WebhooksConfigs = webhooksConfigs; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult.cs new file mode 100644 index 0000000..1152a6e --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult + { + /// + /// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + /// + public readonly bool MsTeams; + /// + /// The endpoint to send HTTP POST requests to. Must be a valid URL + /// + public readonly string Url; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult( + bool msTeams, + + string url) + { + MsTeams = msTeams; + Url = url; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigResult.cs new file mode 100644 index 0000000..8418954 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigResult + { + /// + /// Global configuration for the alerts. + /// + public readonly Outputs.GetObservabilityInstanceAlertConfigGlobalResult Global; + /// + /// List of alert receivers. + /// + public readonly ImmutableArray Receivers; + /// + /// The route for the alert. + /// + public readonly Outputs.GetObservabilityInstanceAlertConfigRouteResult Route; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigResult( + Outputs.GetObservabilityInstanceAlertConfigGlobalResult global, + + ImmutableArray receivers, + + Outputs.GetObservabilityInstanceAlertConfigRouteResult route) + { + Global = global; + Receivers = receivers; + Route = route; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteResult.cs new file mode 100644 index 0000000..b2253cf --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteResult.cs @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigRouteResult + { + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public readonly ImmutableArray GroupBies; + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + public readonly string GroupInterval; + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + /// + public readonly string GroupWait; + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary Match; + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary MatchRegex; + /// + /// The name of the receiver to route the alerts to. + /// + public readonly string Receiver; + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + public readonly string RepeatInterval; + /// + /// List of child routes. + /// + public readonly ImmutableArray Routes; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigRouteResult( + ImmutableArray groupBies, + + string groupInterval, + + string groupWait, + + ImmutableDictionary match, + + ImmutableDictionary matchRegex, + + string receiver, + + string repeatInterval, + + ImmutableArray routes) + { + GroupBies = groupBies; + GroupInterval = groupInterval; + GroupWait = groupWait; + Match = match; + MatchRegex = matchRegex; + Receiver = receiver; + RepeatInterval = repeatInterval; + Routes = routes; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteRouteResult.cs b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteRouteResult.cs new file mode 100644 index 0000000..c5715cc --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityInstanceAlertConfigRouteRouteResult.cs @@ -0,0 +1,70 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityInstanceAlertConfigRouteRouteResult + { + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public readonly ImmutableArray GroupBies; + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + public readonly string GroupInterval; + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + public readonly string GroupWait; + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary Match; + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary MatchRegex; + /// + /// The name of the receiver to route the alerts to. + /// + public readonly string Receiver; + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + public readonly string RepeatInterval; + + [OutputConstructor] + private GetObservabilityInstanceAlertConfigRouteRouteResult( + ImmutableArray groupBies, + + string groupInterval, + + string groupWait, + + ImmutableDictionary match, + + ImmutableDictionary matchRegex, + + string receiver, + + string repeatInterval) + { + GroupBies = groupBies; + GroupInterval = groupInterval; + GroupWait = groupWait; + Match = match; + MatchRegex = matchRegex; + Receiver = receiver; + RepeatInterval = repeatInterval; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityLogalertgroupRuleResult.cs b/sdk/dotnet/Outputs/GetObservabilityLogalertgroupRuleResult.cs new file mode 100644 index 0000000..376a541 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityLogalertgroupRuleResult.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityLogalertgroupRuleResult + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + public readonly string Alert; + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public readonly ImmutableDictionary Annotations; + /// + /// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + public readonly string Expression; + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + public readonly string For; + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public readonly ImmutableDictionary Labels; + + [OutputConstructor] + private GetObservabilityLogalertgroupRuleResult( + string alert, + + ImmutableDictionary annotations, + + string expression, + + string @for, + + ImmutableDictionary labels) + { + Alert = alert; + Annotations = annotations; + Expression = expression; + For = @for; + Labels = labels; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityScrapeconfigBasicAuthResult.cs b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigBasicAuthResult.cs new file mode 100644 index 0000000..fa18db2 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigBasicAuthResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityScrapeconfigBasicAuthResult + { + /// + /// Specifies basic auth password. + /// + public readonly string Password; + /// + /// Specifies basic auth username. + /// + public readonly string Username; + + [OutputConstructor] + private GetObservabilityScrapeconfigBasicAuthResult( + string password, + + string username) + { + Password = password; + Username = username; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityScrapeconfigSaml2Result.cs b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigSaml2Result.cs new file mode 100644 index 0000000..36a914e --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigSaml2Result.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityScrapeconfigSaml2Result + { + /// + /// Specifies if URL parameters are enabled + /// + public readonly bool EnableUrlParameters; + + [OutputConstructor] + private GetObservabilityScrapeconfigSaml2Result(bool enableUrlParameters) + { + EnableUrlParameters = enableUrlParameters; + } + } +} diff --git a/sdk/dotnet/Outputs/GetObservabilityScrapeconfigTargetResult.cs b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigTargetResult.cs new file mode 100644 index 0000000..f932bc7 --- /dev/null +++ b/sdk/dotnet/Outputs/GetObservabilityScrapeconfigTargetResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetObservabilityScrapeconfigTargetResult + { + /// + /// Specifies labels. + /// + public readonly ImmutableDictionary Labels; + /// + /// Specifies target URLs. + /// + public readonly ImmutableArray Urls; + + [OutputConstructor] + private GetObservabilityScrapeconfigTargetResult( + ImmutableDictionary labels, + + ImmutableArray urls) + { + Labels = labels; + Urls = urls; + } + } +} diff --git a/sdk/dotnet/Outputs/GetOpensearchInstanceParametersResult.cs b/sdk/dotnet/Outputs/GetOpensearchInstanceParametersResult.cs new file mode 100644 index 0000000..3a3dfbe --- /dev/null +++ b/sdk/dotnet/Outputs/GetOpensearchInstanceParametersResult.cs @@ -0,0 +1,119 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetOpensearchInstanceParametersResult + { + /// + /// Enable monitoring. + /// + public readonly bool EnableMonitoring; + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + public readonly string Graphite; + /// + /// The garbage collector to use for OpenSearch. + /// + public readonly string JavaGarbageCollector; + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + public readonly int JavaHeapspace; + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + public readonly int JavaMaxmetaspace; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + public readonly int MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + public readonly string MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string MonitoringInstanceId; + /// + /// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + /// + public readonly ImmutableArray Plugins; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// The TLS protocol to use. + /// + public readonly string TlsProtocols; + + [OutputConstructor] + private GetOpensearchInstanceParametersResult( + bool enableMonitoring, + + string graphite, + + string javaGarbageCollector, + + int javaHeapspace, + + int javaMaxmetaspace, + + int maxDiskThreshold, + + int metricsFrequency, + + string metricsPrefix, + + string monitoringInstanceId, + + ImmutableArray plugins, + + string sgwAcl, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string tlsProtocols) + { + EnableMonitoring = enableMonitoring; + Graphite = graphite; + JavaGarbageCollector = javaGarbageCollector; + JavaHeapspace = javaHeapspace; + JavaMaxmetaspace = javaMaxmetaspace; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + Plugins = plugins; + SgwAcl = sgwAcl; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/GetPostgresflexInstanceFlavorResult.cs b/sdk/dotnet/Outputs/GetPostgresflexInstanceFlavorResult.cs new file mode 100644 index 0000000..0adedb7 --- /dev/null +++ b/sdk/dotnet/Outputs/GetPostgresflexInstanceFlavorResult.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetPostgresflexInstanceFlavorResult + { + public readonly int Cpu; + public readonly string Description; + public readonly string Id; + public readonly int Ram; + + [OutputConstructor] + private GetPostgresflexInstanceFlavorResult( + int cpu, + + string description, + + string id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/GetPostgresflexInstanceStorageResult.cs b/sdk/dotnet/Outputs/GetPostgresflexInstanceStorageResult.cs new file mode 100644 index 0000000..6a1c098 --- /dev/null +++ b/sdk/dotnet/Outputs/GetPostgresflexInstanceStorageResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetPostgresflexInstanceStorageResult + { + public readonly string Class; + public readonly int Size; + + [OutputConstructor] + private GetPostgresflexInstanceStorageResult( + string @class, + + int size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/GetPublicIpRangesPublicIpRangeResult.cs b/sdk/dotnet/Outputs/GetPublicIpRangesPublicIpRangeResult.cs new file mode 100644 index 0000000..dd8fe47 --- /dev/null +++ b/sdk/dotnet/Outputs/GetPublicIpRangesPublicIpRangeResult.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetPublicIpRangesPublicIpRangeResult + { + /// + /// Classless Inter-Domain Routing (CIDR) + /// + public readonly string Cidr; + + [OutputConstructor] + private GetPublicIpRangesPublicIpRangeResult(string cidr) + { + Cidr = cidr; + } + } +} diff --git a/sdk/dotnet/Outputs/GetRabbitmqInstanceParametersResult.cs b/sdk/dotnet/Outputs/GetRabbitmqInstanceParametersResult.cs new file mode 100644 index 0000000..37274d6 --- /dev/null +++ b/sdk/dotnet/Outputs/GetRabbitmqInstanceParametersResult.cs @@ -0,0 +1,112 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetRabbitmqInstanceParametersResult + { + /// + /// The timeout in milliseconds for the consumer. + /// + public readonly int ConsumerTimeout; + /// + /// Enable monitoring. + /// + public readonly bool EnableMonitoring; + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + public readonly string Graphite; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string MonitoringInstanceId; + /// + /// List of plugins to install. Must be a supported plugin name. + /// + public readonly ImmutableArray Plugins; + /// + /// List of roles to assign to the instance. + /// + public readonly ImmutableArray Roles; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// TLS protocol to use. + /// + public readonly string TlsProtocols; + + [OutputConstructor] + private GetRabbitmqInstanceParametersResult( + int consumerTimeout, + + bool enableMonitoring, + + string graphite, + + int maxDiskThreshold, + + int metricsFrequency, + + string metricsPrefix, + + string monitoringInstanceId, + + ImmutableArray plugins, + + ImmutableArray roles, + + string sgwAcl, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string tlsProtocols) + { + ConsumerTimeout = consumerTimeout; + EnableMonitoring = enableMonitoring; + Graphite = graphite; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + Plugins = plugins; + Roles = roles; + SgwAcl = sgwAcl; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/GetRedisInstanceParametersResult.cs b/sdk/dotnet/Outputs/GetRedisInstanceParametersResult.cs new file mode 100644 index 0000000..369b830 --- /dev/null +++ b/sdk/dotnet/Outputs/GetRedisInstanceParametersResult.cs @@ -0,0 +1,175 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetRedisInstanceParametersResult + { + /// + /// The number of milliseconds after which the instance is considered down. + /// + public readonly int DownAfterMilliseconds; + /// + /// Enable monitoring. + /// + public readonly bool EnableMonitoring; + /// + /// The failover timeout in milliseconds. + /// + public readonly int FailoverTimeout; + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + public readonly string Graphite; + /// + /// The lazy eviction enablement (yes or no). + /// + public readonly string LazyfreeLazyEviction; + /// + /// The lazy expire enablement (yes or no). + /// + public readonly string LazyfreeLazyExpire; + /// + /// The Lua time limit. + /// + public readonly int LuaTimeLimit; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int MaxDiskThreshold; + /// + /// The maximum number of clients. + /// + public readonly int Maxclients; + /// + /// The policy to handle the maximum memory (volatile-lru, noeviction, etc). + /// + public readonly string MaxmemoryPolicy; + /// + /// The maximum memory samples. + /// + public readonly int MaxmemorySamples; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string MetricsPrefix; + /// + /// The minimum replicas maximum lag. + /// + public readonly int MinReplicasMaxLag; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string MonitoringInstanceId; + /// + /// The notify keyspace events. + /// + public readonly string NotifyKeyspaceEvents; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string SgwAcl; + /// + /// The snapshot configuration. + /// + public readonly string Snapshot; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// TLS cipher suites to use. + /// + public readonly string TlsCiphersuites; + /// + /// TLS protocol to use. + /// + public readonly string TlsProtocols; + + [OutputConstructor] + private GetRedisInstanceParametersResult( + int downAfterMilliseconds, + + bool enableMonitoring, + + int failoverTimeout, + + string graphite, + + string lazyfreeLazyEviction, + + string lazyfreeLazyExpire, + + int luaTimeLimit, + + int maxDiskThreshold, + + int maxclients, + + string maxmemoryPolicy, + + int maxmemorySamples, + + int metricsFrequency, + + string metricsPrefix, + + int minReplicasMaxLag, + + string monitoringInstanceId, + + string notifyKeyspaceEvents, + + string sgwAcl, + + string snapshot, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string tlsCiphersuites, + + string tlsProtocols) + { + DownAfterMilliseconds = downAfterMilliseconds; + EnableMonitoring = enableMonitoring; + FailoverTimeout = failoverTimeout; + Graphite = graphite; + LazyfreeLazyEviction = lazyfreeLazyEviction; + LazyfreeLazyExpire = lazyfreeLazyExpire; + LuaTimeLimit = luaTimeLimit; + MaxDiskThreshold = maxDiskThreshold; + Maxclients = maxclients; + MaxmemoryPolicy = maxmemoryPolicy; + MaxmemorySamples = maxmemorySamples; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MinReplicasMaxLag = minReplicasMaxLag; + MonitoringInstanceId = monitoringInstanceId; + NotifyKeyspaceEvents = notifyKeyspaceEvents; + SgwAcl = sgwAcl; + Snapshot = snapshot; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsCiphersuites = tlsCiphersuites; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSecurityGroupRuleIcmpParametersResult.cs b/sdk/dotnet/Outputs/GetSecurityGroupRuleIcmpParametersResult.cs new file mode 100644 index 0000000..5c7b657 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSecurityGroupRuleIcmpParametersResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSecurityGroupRuleIcmpParametersResult + { + /// + /// ICMP code. Can be set if the protocol is ICMP. + /// + public readonly int Code; + /// + /// ICMP type. Can be set if the protocol is ICMP. + /// + public readonly int Type; + + [OutputConstructor] + private GetSecurityGroupRuleIcmpParametersResult( + int code, + + int type) + { + Code = code; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSecurityGroupRulePortRangeResult.cs b/sdk/dotnet/Outputs/GetSecurityGroupRulePortRangeResult.cs new file mode 100644 index 0000000..edb2322 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSecurityGroupRulePortRangeResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSecurityGroupRulePortRangeResult + { + /// + /// The maximum port number. Should be greater or equal to the minimum. + /// + public readonly int Max; + /// + /// The minimum port number. Should be less or equal to the minimum. + /// + public readonly int Min; + + [OutputConstructor] + private GetSecurityGroupRulePortRangeResult( + int max, + + int min) + { + Max = max; + Min = min; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSecurityGroupRuleProtocolResult.cs b/sdk/dotnet/Outputs/GetSecurityGroupRuleProtocolResult.cs new file mode 100644 index 0000000..25fb846 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSecurityGroupRuleProtocolResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSecurityGroupRuleProtocolResult + { + /// + /// The protocol name which the rule should match. + /// + public readonly string Name; + /// + /// The protocol number which the rule should match. + /// + public readonly int Number; + + [OutputConstructor] + private GetSecurityGroupRuleProtocolResult( + string name, + + int number) + { + Name = name; + Number = number; + } + } +} diff --git a/sdk/dotnet/Outputs/GetServerBackupScheduleBackupPropertiesResult.cs b/sdk/dotnet/Outputs/GetServerBackupScheduleBackupPropertiesResult.cs new file mode 100644 index 0000000..0c73b47 --- /dev/null +++ b/sdk/dotnet/Outputs/GetServerBackupScheduleBackupPropertiesResult.cs @@ -0,0 +1,33 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetServerBackupScheduleBackupPropertiesResult + { + public readonly string Name; + public readonly int RetentionPeriod; + public readonly ImmutableArray VolumeIds; + + [OutputConstructor] + private GetServerBackupScheduleBackupPropertiesResult( + string name, + + int retentionPeriod, + + ImmutableArray volumeIds) + { + Name = name; + RetentionPeriod = retentionPeriod; + VolumeIds = volumeIds; + } + } +} diff --git a/sdk/dotnet/Outputs/GetServerBackupSchedulesItemBackupPropertiesResult.cs b/sdk/dotnet/Outputs/GetServerBackupSchedulesItemBackupPropertiesResult.cs new file mode 100644 index 0000000..997180a --- /dev/null +++ b/sdk/dotnet/Outputs/GetServerBackupSchedulesItemBackupPropertiesResult.cs @@ -0,0 +1,33 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetServerBackupSchedulesItemBackupPropertiesResult + { + public readonly string Name; + public readonly int RetentionPeriod; + public readonly ImmutableArray VolumeIds; + + [OutputConstructor] + private GetServerBackupSchedulesItemBackupPropertiesResult( + string name, + + int retentionPeriod, + + ImmutableArray volumeIds) + { + Name = name; + RetentionPeriod = retentionPeriod; + VolumeIds = volumeIds; + } + } +} diff --git a/sdk/dotnet/Outputs/GetServerBackupSchedulesItemResult.cs b/sdk/dotnet/Outputs/GetServerBackupSchedulesItemResult.cs new file mode 100644 index 0000000..507dc91 --- /dev/null +++ b/sdk/dotnet/Outputs/GetServerBackupSchedulesItemResult.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetServerBackupSchedulesItemResult + { + /// + /// Backup schedule details for the backups. + /// + public readonly Outputs.GetServerBackupSchedulesItemBackupPropertiesResult BackupProperties; + public readonly int BackupScheduleId; + /// + /// Is the backup schedule enabled or disabled. + /// + public readonly bool Enabled; + /// + /// The backup schedule name. + /// + public readonly string Name; + /// + /// Backup schedule described in `rrule` (recurrence rule) format. + /// + public readonly string Rrule; + + [OutputConstructor] + private GetServerBackupSchedulesItemResult( + Outputs.GetServerBackupSchedulesItemBackupPropertiesResult backupProperties, + + int backupScheduleId, + + bool enabled, + + string name, + + string rrule) + { + BackupProperties = backupProperties; + BackupScheduleId = backupScheduleId; + Enabled = enabled; + Name = name; + Rrule = rrule; + } + } +} diff --git a/sdk/dotnet/Outputs/GetServerBootVolumeResult.cs b/sdk/dotnet/Outputs/GetServerBootVolumeResult.cs new file mode 100644 index 0000000..ccddec3 --- /dev/null +++ b/sdk/dotnet/Outputs/GetServerBootVolumeResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetServerBootVolumeResult + { + /// + /// Delete the volume during the termination of the server. + /// + public readonly bool DeleteOnTermination; + /// + /// The ID of the boot volume + /// + public readonly string Id; + + [OutputConstructor] + private GetServerBootVolumeResult( + bool deleteOnTermination, + + string id) + { + DeleteOnTermination = deleteOnTermination; + Id = id; + } + } +} diff --git a/sdk/dotnet/Outputs/GetServerUpdateSchedulesItemResult.cs b/sdk/dotnet/Outputs/GetServerUpdateSchedulesItemResult.cs new file mode 100644 index 0000000..9e2b866 --- /dev/null +++ b/sdk/dotnet/Outputs/GetServerUpdateSchedulesItemResult.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetServerUpdateSchedulesItemResult + { + /// + /// Is the update schedule enabled or disabled. + /// + public readonly bool Enabled; + /// + /// Maintenance window [1..24]. + /// + public readonly int MaintenanceWindow; + /// + /// The update schedule name. + /// + public readonly string Name; + /// + /// Update schedule described in `rrule` (recurrence rule) format. + /// + public readonly string Rrule; + public readonly int UpdateScheduleId; + + [OutputConstructor] + private GetServerUpdateSchedulesItemResult( + bool enabled, + + int maintenanceWindow, + + string name, + + string rrule, + + int updateScheduleId) + { + Enabled = enabled; + MaintenanceWindow = maintenanceWindow; + Name = name; + Rrule = rrule; + UpdateScheduleId = updateScheduleId; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterExtensionsAclResult.cs b/sdk/dotnet/Outputs/GetSkeClusterExtensionsAclResult.cs new file mode 100644 index 0000000..5685b34 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterExtensionsAclResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterExtensionsAclResult + { + /// + /// Specify a list of CIDRs to whitelist + /// + public readonly ImmutableArray AllowedCidrs; + /// + /// Is ACL enabled? + /// + public readonly bool Enabled; + + [OutputConstructor] + private GetSkeClusterExtensionsAclResult( + ImmutableArray allowedCidrs, + + bool enabled) + { + AllowedCidrs = allowedCidrs; + Enabled = enabled; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterExtensionsArgusResult.cs b/sdk/dotnet/Outputs/GetSkeClusterExtensionsArgusResult.cs new file mode 100644 index 0000000..38ddf93 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterExtensionsArgusResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterExtensionsArgusResult + { + /// + /// Instance ID of argus + /// + public readonly string ArgusInstanceId; + /// + /// Flag to enable/disable argus extensions. + /// + public readonly bool Enabled; + + [OutputConstructor] + private GetSkeClusterExtensionsArgusResult( + string argusInstanceId, + + bool enabled) + { + ArgusInstanceId = argusInstanceId; + Enabled = enabled; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterExtensionsDnsResult.cs b/sdk/dotnet/Outputs/GetSkeClusterExtensionsDnsResult.cs new file mode 100644 index 0000000..7aa766a --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterExtensionsDnsResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterExtensionsDnsResult + { + /// + /// Flag to enable/disable DNS extensions + /// + public readonly bool Enabled; + /// + /// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + /// + public readonly ImmutableArray Zones; + + [OutputConstructor] + private GetSkeClusterExtensionsDnsResult( + bool enabled, + + ImmutableArray zones) + { + Enabled = enabled; + Zones = zones; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterExtensionsResult.cs b/sdk/dotnet/Outputs/GetSkeClusterExtensionsResult.cs new file mode 100644 index 0000000..63d46da --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterExtensionsResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterExtensionsResult + { + /// + /// Cluster access control configuration + /// + public readonly Outputs.GetSkeClusterExtensionsAclResult Acl; + /// + /// A single argus block as defined below + /// + public readonly Outputs.GetSkeClusterExtensionsArgusResult Argus; + /// + /// DNS extension configuration + /// + public readonly Outputs.GetSkeClusterExtensionsDnsResult Dns; + + [OutputConstructor] + private GetSkeClusterExtensionsResult( + Outputs.GetSkeClusterExtensionsAclResult acl, + + Outputs.GetSkeClusterExtensionsArgusResult argus, + + Outputs.GetSkeClusterExtensionsDnsResult dns) + { + Acl = acl; + Argus = argus; + Dns = dns; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterHibernationResult.cs b/sdk/dotnet/Outputs/GetSkeClusterHibernationResult.cs new file mode 100644 index 0000000..29a1635 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterHibernationResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterHibernationResult + { + /// + /// End time of hibernation, in crontab syntax. + /// + public readonly string End; + /// + /// Start time of cluster hibernation in crontab syntax. + /// + public readonly string Start; + /// + /// Timezone name corresponding to a file in the IANA Time Zone database. + /// + public readonly string Timezone; + + [OutputConstructor] + private GetSkeClusterHibernationResult( + string end, + + string start, + + string timezone) + { + End = end; + Start = start; + Timezone = timezone; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterMaintenanceResult.cs b/sdk/dotnet/Outputs/GetSkeClusterMaintenanceResult.cs new file mode 100644 index 0000000..9cb2154 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterMaintenanceResult.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterMaintenanceResult + { + /// + /// Flag to enable/disable auto-updates of the Kubernetes version. + /// + public readonly bool EnableKubernetesVersionUpdates; + /// + /// Flag to enable/disable auto-updates of the OS image version. + /// + public readonly bool EnableMachineImageVersionUpdates; + /// + /// Date time for maintenance window end. + /// + public readonly string End; + /// + /// Date time for maintenance window start. + /// + public readonly string Start; + + [OutputConstructor] + private GetSkeClusterMaintenanceResult( + bool enableKubernetesVersionUpdates, + + bool enableMachineImageVersionUpdates, + + string end, + + string start) + { + EnableKubernetesVersionUpdates = enableKubernetesVersionUpdates; + EnableMachineImageVersionUpdates = enableMachineImageVersionUpdates; + End = end; + Start = start; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterNetworkResult.cs b/sdk/dotnet/Outputs/GetSkeClusterNetworkResult.cs new file mode 100644 index 0000000..f102497 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterNetworkResult.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterNetworkResult + { + /// + /// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + /// + public readonly string Id; + + [OutputConstructor] + private GetSkeClusterNetworkResult(string id) + { + Id = id; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterNodePoolResult.cs b/sdk/dotnet/Outputs/GetSkeClusterNodePoolResult.cs new file mode 100644 index 0000000..d04c6be --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterNodePoolResult.cs @@ -0,0 +1,140 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterNodePoolResult + { + /// + /// Allow system components to run on this node pool. + /// + public readonly bool AllowSystemComponents; + /// + /// Specify a list of availability zones. + /// + public readonly ImmutableArray AvailabilityZones; + /// + /// Specifies the container runtime. + /// + public readonly string Cri; + /// + /// Labels to add to each node. + /// + public readonly ImmutableDictionary Labels; + /// + /// The machine type. + /// + public readonly string MachineType; + /// + /// The maximum number of nodes upgraded simultaneously. + /// + public readonly int MaxSurge; + /// + /// The maximum number of nodes unavailable during upgraded. + /// + public readonly int MaxUnavailable; + /// + /// Maximum number of nodes in the pool. + /// + public readonly int Maximum; + /// + /// Minimum number of nodes in the pool. + /// + public readonly int Minimum; + /// + /// Specifies the name of the node pool. + /// + public readonly string Name; + /// + /// The name of the OS image. + /// + public readonly string OsName; + /// + /// The OS image version. + /// + public readonly string OsVersion; + /// + /// The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + /// + public readonly string OsVersionMin; + /// + /// Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + public readonly string OsVersionUsed; + /// + /// Specifies a taint list as defined below. + /// + public readonly ImmutableArray Taints; + /// + /// The volume size in GB. + /// + public readonly int VolumeSize; + /// + /// Specifies the volume type. + /// + public readonly string VolumeType; + + [OutputConstructor] + private GetSkeClusterNodePoolResult( + bool allowSystemComponents, + + ImmutableArray availabilityZones, + + string cri, + + ImmutableDictionary labels, + + string machineType, + + int maxSurge, + + int maxUnavailable, + + int maximum, + + int minimum, + + string name, + + string osName, + + string osVersion, + + string osVersionMin, + + string osVersionUsed, + + ImmutableArray taints, + + int volumeSize, + + string volumeType) + { + AllowSystemComponents = allowSystemComponents; + AvailabilityZones = availabilityZones; + Cri = cri; + Labels = labels; + MachineType = machineType; + MaxSurge = maxSurge; + MaxUnavailable = maxUnavailable; + Maximum = maximum; + Minimum = minimum; + Name = name; + OsName = osName; + OsVersion = osVersion; + OsVersionMin = osVersionMin; + OsVersionUsed = osVersionUsed; + Taints = taints; + VolumeSize = volumeSize; + VolumeType = volumeType; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSkeClusterNodePoolTaintResult.cs b/sdk/dotnet/Outputs/GetSkeClusterNodePoolTaintResult.cs new file mode 100644 index 0000000..49ab070 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSkeClusterNodePoolTaintResult.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSkeClusterNodePoolTaintResult + { + /// + /// The taint effect. + /// + public readonly string Effect; + /// + /// Taint key to be applied to a node. + /// + public readonly string Key; + /// + /// Taint value corresponding to the taint key. + /// + public readonly string Value; + + [OutputConstructor] + private GetSkeClusterNodePoolTaintResult( + string effect, + + string key, + + string value) + { + Effect = effect; + Key = key; + Value = value; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSqlserverflexInstanceFlavorResult.cs b/sdk/dotnet/Outputs/GetSqlserverflexInstanceFlavorResult.cs new file mode 100644 index 0000000..71e9fdb --- /dev/null +++ b/sdk/dotnet/Outputs/GetSqlserverflexInstanceFlavorResult.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSqlserverflexInstanceFlavorResult + { + public readonly int Cpu; + public readonly string Description; + public readonly string Id; + public readonly int Ram; + + [OutputConstructor] + private GetSqlserverflexInstanceFlavorResult( + int cpu, + + string description, + + string id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSqlserverflexInstanceOptionsResult.cs b/sdk/dotnet/Outputs/GetSqlserverflexInstanceOptionsResult.cs new file mode 100644 index 0000000..7e6b91c --- /dev/null +++ b/sdk/dotnet/Outputs/GetSqlserverflexInstanceOptionsResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSqlserverflexInstanceOptionsResult + { + public readonly string Edition; + public readonly int RetentionDays; + + [OutputConstructor] + private GetSqlserverflexInstanceOptionsResult( + string edition, + + int retentionDays) + { + Edition = edition; + RetentionDays = retentionDays; + } + } +} diff --git a/sdk/dotnet/Outputs/GetSqlserverflexInstanceStorageResult.cs b/sdk/dotnet/Outputs/GetSqlserverflexInstanceStorageResult.cs new file mode 100644 index 0000000..fd48314 --- /dev/null +++ b/sdk/dotnet/Outputs/GetSqlserverflexInstanceStorageResult.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetSqlserverflexInstanceStorageResult + { + public readonly string Class; + public readonly int Size; + + [OutputConstructor] + private GetSqlserverflexInstanceStorageResult( + string @class, + + int size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/GetVolumeSourceResult.cs b/sdk/dotnet/Outputs/GetVolumeSourceResult.cs new file mode 100644 index 0000000..aa699a3 --- /dev/null +++ b/sdk/dotnet/Outputs/GetVolumeSourceResult.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class GetVolumeSourceResult + { + /// + /// The ID of the source, e.g. image ID + /// + public readonly string Id; + /// + /// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + /// + public readonly string Type; + + [OutputConstructor] + private GetVolumeSourceResult( + string id, + + string type) + { + Id = id; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/ImageChecksum.cs b/sdk/dotnet/Outputs/ImageChecksum.cs new file mode 100644 index 0000000..1d750e7 --- /dev/null +++ b/sdk/dotnet/Outputs/ImageChecksum.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ImageChecksum + { + /// + /// Algorithm for the checksum of the image data. + /// + public readonly string? Algorithm; + /// + /// Hexdigest of the checksum of the image data. + /// + public readonly string? Digest; + + [OutputConstructor] + private ImageChecksum( + string? algorithm, + + string? digest) + { + Algorithm = algorithm; + Digest = digest; + } + } +} diff --git a/sdk/dotnet/Outputs/ImageConfig.cs b/sdk/dotnet/Outputs/ImageConfig.cs new file mode 100644 index 0000000..dfd0928 --- /dev/null +++ b/sdk/dotnet/Outputs/ImageConfig.cs @@ -0,0 +1,112 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ImageConfig + { + /// + /// Enables the BIOS bootmenu. + /// + public readonly bool? BootMenu; + /// + /// Sets CDROM bus controller type. + /// + public readonly string? CdromBus; + /// + /// Sets Disk bus controller type. + /// + public readonly string? DiskBus; + /// + /// Sets virtual network interface model. + /// + public readonly string? NicModel; + /// + /// Enables operating system specific optimizations. + /// + public readonly string? OperatingSystem; + /// + /// Operating system distribution. + /// + public readonly string? OperatingSystemDistro; + /// + /// Version of the operating system. + /// + public readonly string? OperatingSystemVersion; + /// + /// Sets the device bus when the image is used as a rescue image. + /// + public readonly string? RescueBus; + /// + /// Sets the device when the image is used as a rescue image. + /// + public readonly string? RescueDevice; + /// + /// Enables Secure Boot. + /// + public readonly bool? SecureBoot; + /// + /// Enables UEFI boot. + /// + public readonly bool? Uefi; + /// + /// Sets Graphic device model. + /// + public readonly string? VideoModel; + /// + /// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + /// + public readonly bool? VirtioScsi; + + [OutputConstructor] + private ImageConfig( + bool? bootMenu, + + string? cdromBus, + + string? diskBus, + + string? nicModel, + + string? operatingSystem, + + string? operatingSystemDistro, + + string? operatingSystemVersion, + + string? rescueBus, + + string? rescueDevice, + + bool? secureBoot, + + bool? uefi, + + string? videoModel, + + bool? virtioScsi) + { + BootMenu = bootMenu; + CdromBus = cdromBus; + DiskBus = diskBus; + NicModel = nicModel; + OperatingSystem = operatingSystem; + OperatingSystemDistro = operatingSystemDistro; + OperatingSystemVersion = operatingSystemVersion; + RescueBus = rescueBus; + RescueDevice = rescueDevice; + SecureBoot = secureBoot; + Uefi = uefi; + VideoModel = videoModel; + VirtioScsi = virtioScsi; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerListener.cs b/sdk/dotnet/Outputs/LoadbalancerListener.cs new file mode 100644 index 0000000..9333066 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerListener.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerListener + { + public readonly string? DisplayName; + /// + /// Port number where we listen for traffic. + /// + public readonly int Port; + /// + /// Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + /// + public readonly string Protocol; + /// + /// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + /// + public readonly ImmutableArray ServerNameIndicators; + /// + /// Reference target pool by target pool name. + /// + public readonly string TargetPool; + + [OutputConstructor] + private LoadbalancerListener( + string? displayName, + + int port, + + string protocol, + + ImmutableArray serverNameIndicators, + + string targetPool) + { + DisplayName = displayName; + Port = port; + Protocol = protocol; + ServerNameIndicators = serverNameIndicators; + TargetPool = targetPool; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerListenerServerNameIndicator.cs b/sdk/dotnet/Outputs/LoadbalancerListenerServerNameIndicator.cs new file mode 100644 index 0000000..2631a53 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerListenerServerNameIndicator.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerListenerServerNameIndicator + { + /// + /// A domain name to match in order to pass TLS traffic to the target pool in the current listener + /// + public readonly string? Name; + + [OutputConstructor] + private LoadbalancerListenerServerNameIndicator(string? name) + { + Name = name; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerNetwork.cs b/sdk/dotnet/Outputs/LoadbalancerNetwork.cs new file mode 100644 index 0000000..f5d0792 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerNetwork.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerNetwork + { + /// + /// Openstack network ID. + /// + public readonly string NetworkId; + /// + /// The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + /// + public readonly string Role; + + [OutputConstructor] + private LoadbalancerNetwork( + string networkId, + + string role) + { + NetworkId = networkId; + Role = role; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerOptions.cs b/sdk/dotnet/Outputs/LoadbalancerOptions.cs new file mode 100644 index 0000000..b89bb7e --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerOptions.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerOptions + { + /// + /// Load Balancer is accessible only from an IP address in this range. + /// + public readonly ImmutableArray Acls; + /// + /// We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + /// + public readonly Outputs.LoadbalancerOptionsObservability? Observability; + /// + /// If true, Load Balancer is accessible only via a private network IP address. + /// + public readonly bool? PrivateNetworkOnly; + + [OutputConstructor] + private LoadbalancerOptions( + ImmutableArray acls, + + Outputs.LoadbalancerOptionsObservability? observability, + + bool? privateNetworkOnly) + { + Acls = acls; + Observability = observability; + PrivateNetworkOnly = privateNetworkOnly; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerOptionsObservability.cs b/sdk/dotnet/Outputs/LoadbalancerOptionsObservability.cs new file mode 100644 index 0000000..45bf581 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerOptionsObservability.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerOptionsObservability + { + /// + /// Observability logs configuration. Not changeable after creation. + /// + public readonly Outputs.LoadbalancerOptionsObservabilityLogs? Logs; + /// + /// Observability metrics configuration. Not changeable after creation. + /// + public readonly Outputs.LoadbalancerOptionsObservabilityMetrics? Metrics; + + [OutputConstructor] + private LoadbalancerOptionsObservability( + Outputs.LoadbalancerOptionsObservabilityLogs? logs, + + Outputs.LoadbalancerOptionsObservabilityMetrics? metrics) + { + Logs = logs; + Metrics = metrics; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityLogs.cs b/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityLogs.cs new file mode 100644 index 0000000..799c0c7 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityLogs.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerOptionsObservabilityLogs + { + /// + /// Credentials reference for logs. Not changeable after creation. + /// + public readonly string? CredentialsRef; + /// + /// Credentials reference for logs. Not changeable after creation. + /// + public readonly string? PushUrl; + + [OutputConstructor] + private LoadbalancerOptionsObservabilityLogs( + string? credentialsRef, + + string? pushUrl) + { + CredentialsRef = credentialsRef; + PushUrl = pushUrl; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityMetrics.cs b/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityMetrics.cs new file mode 100644 index 0000000..b08ca2e --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerOptionsObservabilityMetrics.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerOptionsObservabilityMetrics + { + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + public readonly string? CredentialsRef; + /// + /// Credentials reference for metrics. Not changeable after creation. + /// + public readonly string? PushUrl; + + [OutputConstructor] + private LoadbalancerOptionsObservabilityMetrics( + string? credentialsRef, + + string? pushUrl) + { + CredentialsRef = credentialsRef; + PushUrl = pushUrl; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerTargetPool.cs b/sdk/dotnet/Outputs/LoadbalancerTargetPool.cs new file mode 100644 index 0000000..c31b03b --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerTargetPool.cs @@ -0,0 +1,53 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerTargetPool + { + public readonly Outputs.LoadbalancerTargetPoolActiveHealthCheck? ActiveHealthCheck; + /// + /// Target pool name. + /// + public readonly string Name; + /// + /// Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + /// + public readonly Outputs.LoadbalancerTargetPoolSessionPersistence? SessionPersistence; + /// + /// Identical port number where each target listens for traffic. + /// + public readonly int TargetPort; + /// + /// List of all targets which will be used in the pool. Limited to 1000. + /// + public readonly ImmutableArray Targets; + + [OutputConstructor] + private LoadbalancerTargetPool( + Outputs.LoadbalancerTargetPoolActiveHealthCheck? activeHealthCheck, + + string name, + + Outputs.LoadbalancerTargetPoolSessionPersistence? sessionPersistence, + + int targetPort, + + ImmutableArray targets) + { + ActiveHealthCheck = activeHealthCheck; + Name = name; + SessionPersistence = sessionPersistence; + TargetPort = targetPort; + Targets = targets; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerTargetPoolActiveHealthCheck.cs b/sdk/dotnet/Outputs/LoadbalancerTargetPoolActiveHealthCheck.cs new file mode 100644 index 0000000..c953142 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerTargetPoolActiveHealthCheck.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerTargetPoolActiveHealthCheck + { + /// + /// Healthy threshold of the health checking. + /// + public readonly int? HealthyThreshold; + /// + /// Interval duration of health checking in seconds. + /// + public readonly string? Interval; + /// + /// Interval duration threshold of the health checking in seconds. + /// + public readonly string? IntervalJitter; + /// + /// Active health checking timeout duration in seconds. + /// + public readonly string? Timeout; + /// + /// Unhealthy threshold of the health checking. + /// + public readonly int? UnhealthyThreshold; + + [OutputConstructor] + private LoadbalancerTargetPoolActiveHealthCheck( + int? healthyThreshold, + + string? interval, + + string? intervalJitter, + + string? timeout, + + int? unhealthyThreshold) + { + HealthyThreshold = healthyThreshold; + Interval = interval; + IntervalJitter = intervalJitter; + Timeout = timeout; + UnhealthyThreshold = unhealthyThreshold; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerTargetPoolSessionPersistence.cs b/sdk/dotnet/Outputs/LoadbalancerTargetPoolSessionPersistence.cs new file mode 100644 index 0000000..f3eefa5 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerTargetPoolSessionPersistence.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerTargetPoolSessionPersistence + { + /// + /// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + /// + public readonly bool? UseSourceIpAddress; + + [OutputConstructor] + private LoadbalancerTargetPoolSessionPersistence(bool? useSourceIpAddress) + { + UseSourceIpAddress = useSourceIpAddress; + } + } +} diff --git a/sdk/dotnet/Outputs/LoadbalancerTargetPoolTarget.cs b/sdk/dotnet/Outputs/LoadbalancerTargetPoolTarget.cs new file mode 100644 index 0000000..3e63dc1 --- /dev/null +++ b/sdk/dotnet/Outputs/LoadbalancerTargetPoolTarget.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LoadbalancerTargetPoolTarget + { + /// + /// Target display name + /// + public readonly string DisplayName; + /// + /// Target IP + /// + public readonly string Ip; + + [OutputConstructor] + private LoadbalancerTargetPoolTarget( + string displayName, + + string ip) + { + DisplayName = displayName; + Ip = ip; + } + } +} diff --git a/sdk/dotnet/Outputs/LogmeInstanceParameters.cs b/sdk/dotnet/Outputs/LogmeInstanceParameters.cs new file mode 100644 index 0000000..e888531 --- /dev/null +++ b/sdk/dotnet/Outputs/LogmeInstanceParameters.cs @@ -0,0 +1,145 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class LogmeInstanceParameters + { + /// + /// Enable monitoring. + /// + public readonly bool? EnableMonitoring; + public readonly int? FluentdTcp; + public readonly int? FluentdTls; + public readonly string? FluentdTlsCiphers; + public readonly string? FluentdTlsMaxVersion; + public readonly string? FluentdTlsMinVersion; + public readonly string? FluentdTlsVersion; + public readonly int? FluentdUdp; + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + public readonly string? Graphite; + /// + /// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + /// + public readonly string? IsmDeletionAfter; + public readonly double? IsmJitter; + /// + /// Jitter of the execution time. + /// + public readonly int? IsmJobInterval; + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + public readonly int? JavaHeapspace; + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + public readonly int? JavaMaxmetaspace; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int? MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + public readonly int? MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + public readonly string? MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string? MonitoringInstanceId; + public readonly ImmutableArray OpensearchTlsCiphers; + public readonly ImmutableArray OpensearchTlsProtocols; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string? SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + + [OutputConstructor] + private LogmeInstanceParameters( + bool? enableMonitoring, + + int? fluentdTcp, + + int? fluentdTls, + + string? fluentdTlsCiphers, + + string? fluentdTlsMaxVersion, + + string? fluentdTlsMinVersion, + + string? fluentdTlsVersion, + + int? fluentdUdp, + + string? graphite, + + string? ismDeletionAfter, + + double? ismJitter, + + int? ismJobInterval, + + int? javaHeapspace, + + int? javaMaxmetaspace, + + int? maxDiskThreshold, + + int? metricsFrequency, + + string? metricsPrefix, + + string? monitoringInstanceId, + + ImmutableArray opensearchTlsCiphers, + + ImmutableArray opensearchTlsProtocols, + + string? sgwAcl, + + ImmutableArray syslogs) + { + EnableMonitoring = enableMonitoring; + FluentdTcp = fluentdTcp; + FluentdTls = fluentdTls; + FluentdTlsCiphers = fluentdTlsCiphers; + FluentdTlsMaxVersion = fluentdTlsMaxVersion; + FluentdTlsMinVersion = fluentdTlsMinVersion; + FluentdTlsVersion = fluentdTlsVersion; + FluentdUdp = fluentdUdp; + Graphite = graphite; + IsmDeletionAfter = ismDeletionAfter; + IsmJitter = ismJitter; + IsmJobInterval = ismJobInterval; + JavaHeapspace = javaHeapspace; + JavaMaxmetaspace = javaMaxmetaspace; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + OpensearchTlsCiphers = opensearchTlsCiphers; + OpensearchTlsProtocols = opensearchTlsProtocols; + SgwAcl = sgwAcl; + Syslogs = syslogs; + } + } +} diff --git a/sdk/dotnet/Outputs/MariadbInstanceParameters.cs b/sdk/dotnet/Outputs/MariadbInstanceParameters.cs new file mode 100644 index 0000000..a87a8b4 --- /dev/null +++ b/sdk/dotnet/Outputs/MariadbInstanceParameters.cs @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class MariadbInstanceParameters + { + /// + /// Enable monitoring. + /// + public readonly bool? EnableMonitoring; + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + public readonly string? Graphite; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int? MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int? MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string? MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + /// + public readonly string? MonitoringInstanceId; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string? SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + + [OutputConstructor] + private MariadbInstanceParameters( + bool? enableMonitoring, + + string? graphite, + + int? maxDiskThreshold, + + int? metricsFrequency, + + string? metricsPrefix, + + string? monitoringInstanceId, + + string? sgwAcl, + + ImmutableArray syslogs) + { + EnableMonitoring = enableMonitoring; + Graphite = graphite; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + SgwAcl = sgwAcl; + Syslogs = syslogs; + } + } +} diff --git a/sdk/dotnet/Outputs/MongodbflexInstanceFlavor.cs b/sdk/dotnet/Outputs/MongodbflexInstanceFlavor.cs new file mode 100644 index 0000000..068f01e --- /dev/null +++ b/sdk/dotnet/Outputs/MongodbflexInstanceFlavor.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class MongodbflexInstanceFlavor + { + public readonly int Cpu; + public readonly string? Description; + public readonly string? Id; + public readonly int Ram; + + [OutputConstructor] + private MongodbflexInstanceFlavor( + int cpu, + + string? description, + + string? id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/MongodbflexInstanceOptions.cs b/sdk/dotnet/Outputs/MongodbflexInstanceOptions.cs new file mode 100644 index 0000000..dcbedc0 --- /dev/null +++ b/sdk/dotnet/Outputs/MongodbflexInstanceOptions.cs @@ -0,0 +1,63 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class MongodbflexInstanceOptions + { + /// + /// The number of days that daily backups will be retained. + /// + public readonly int? DailySnapshotRetentionDays; + /// + /// The number of months that monthly backups will be retained. + /// + public readonly int? MonthlySnapshotRetentionMonths; + /// + /// The number of hours back in time the point-in-time recovery feature will be able to recover. + /// + public readonly int PointInTimeWindowHours; + /// + /// The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + /// + public readonly int? SnapshotRetentionDays; + /// + /// Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + /// + public readonly string Type; + /// + /// The number of weeks that weekly backups will be retained. + /// + public readonly int? WeeklySnapshotRetentionWeeks; + + [OutputConstructor] + private MongodbflexInstanceOptions( + int? dailySnapshotRetentionDays, + + int? monthlySnapshotRetentionMonths, + + int pointInTimeWindowHours, + + int? snapshotRetentionDays, + + string type, + + int? weeklySnapshotRetentionWeeks) + { + DailySnapshotRetentionDays = dailySnapshotRetentionDays; + MonthlySnapshotRetentionMonths = monthlySnapshotRetentionMonths; + PointInTimeWindowHours = pointInTimeWindowHours; + SnapshotRetentionDays = snapshotRetentionDays; + Type = type; + WeeklySnapshotRetentionWeeks = weeklySnapshotRetentionWeeks; + } + } +} diff --git a/sdk/dotnet/Outputs/MongodbflexInstanceStorage.cs b/sdk/dotnet/Outputs/MongodbflexInstanceStorage.cs new file mode 100644 index 0000000..9d84a1c --- /dev/null +++ b/sdk/dotnet/Outputs/MongodbflexInstanceStorage.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class MongodbflexInstanceStorage + { + public readonly string Class; + public readonly int Size; + + [OutputConstructor] + private MongodbflexInstanceStorage( + string @class, + + int size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/NetworkAreaNetworkRange.cs b/sdk/dotnet/Outputs/NetworkAreaNetworkRange.cs new file mode 100644 index 0000000..ffff57a --- /dev/null +++ b/sdk/dotnet/Outputs/NetworkAreaNetworkRange.cs @@ -0,0 +1,32 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class NetworkAreaNetworkRange + { + public readonly string? NetworkRangeId; + /// + /// Classless Inter-Domain Routing (CIDR). + /// + public readonly string Prefix; + + [OutputConstructor] + private NetworkAreaNetworkRange( + string? networkRangeId, + + string prefix) + { + NetworkRangeId = networkRangeId; + Prefix = prefix; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityAlertgroupRule.cs b/sdk/dotnet/Outputs/ObservabilityAlertgroupRule.cs new file mode 100644 index 0000000..fc27012 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityAlertgroupRule.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityAlertgroupRule + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + public readonly string Alert; + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public readonly ImmutableDictionary? Annotations; + /// + /// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + public readonly string Expression; + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + public readonly string? For; + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public readonly ImmutableDictionary? Labels; + + [OutputConstructor] + private ObservabilityAlertgroupRule( + string alert, + + ImmutableDictionary? annotations, + + string expression, + + string? @for, + + ImmutableDictionary? labels) + { + Alert = alert; + Annotations = annotations; + Expression = expression; + For = @for; + Labels = labels; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfig.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfig.cs new file mode 100644 index 0000000..a36bcce --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfig.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfig + { + /// + /// Global configuration for the alerts. + /// + public readonly Outputs.ObservabilityInstanceAlertConfigGlobal? Global; + /// + /// List of alert receivers. + /// + public readonly ImmutableArray Receivers; + /// + /// Route configuration for the alerts. + /// + public readonly Outputs.ObservabilityInstanceAlertConfigRoute Route; + + [OutputConstructor] + private ObservabilityInstanceAlertConfig( + Outputs.ObservabilityInstanceAlertConfigGlobal? global, + + ImmutableArray receivers, + + Outputs.ObservabilityInstanceAlertConfigRoute route) + { + Global = global; + Receivers = receivers; + Route = route; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigGlobal.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigGlobal.cs new file mode 100644 index 0000000..661542d --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigGlobal.cs @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigGlobal + { + /// + /// The API key for OpsGenie. + /// + public readonly string? OpsgenieApiKey; + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + public readonly string? OpsgenieApiUrl; + /// + /// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + /// + public readonly string? ResolveTimeout; + /// + /// SMTP authentication information. Must be a valid email address + /// + public readonly string? SmtpAuthIdentity; + /// + /// SMTP Auth using LOGIN and PLAIN. + /// + public readonly string? SmtpAuthPassword; + /// + /// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + /// + public readonly string? SmtpAuthUsername; + /// + /// The default SMTP From header field. Must be a valid email address + /// + public readonly string? SmtpFrom; + /// + /// The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + /// + public readonly string? SmtpSmartHost; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigGlobal( + string? opsgenieApiKey, + + string? opsgenieApiUrl, + + string? resolveTimeout, + + string? smtpAuthIdentity, + + string? smtpAuthPassword, + + string? smtpAuthUsername, + + string? smtpFrom, + + string? smtpSmartHost) + { + OpsgenieApiKey = opsgenieApiKey; + OpsgenieApiUrl = opsgenieApiUrl; + ResolveTimeout = resolveTimeout; + SmtpAuthIdentity = smtpAuthIdentity; + SmtpAuthPassword = smtpAuthPassword; + SmtpAuthUsername = smtpAuthUsername; + SmtpFrom = smtpFrom; + SmtpSmartHost = smtpSmartHost; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiver.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiver.cs new file mode 100644 index 0000000..19595ce --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiver.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigReceiver + { + /// + /// List of email configurations. + /// + public readonly ImmutableArray EmailConfigs; + /// + /// Name of the receiver. + /// + public readonly string Name; + /// + /// List of OpsGenie configurations. + /// + public readonly ImmutableArray OpsgenieConfigs; + /// + /// List of Webhooks configurations. + /// + public readonly ImmutableArray WebhooksConfigs; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigReceiver( + ImmutableArray emailConfigs, + + string name, + + ImmutableArray opsgenieConfigs, + + ImmutableArray webhooksConfigs) + { + EmailConfigs = emailConfigs; + Name = name; + OpsgenieConfigs = opsgenieConfigs; + WebhooksConfigs = webhooksConfigs; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverEmailConfig.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverEmailConfig.cs new file mode 100644 index 0000000..1117a97 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverEmailConfig.cs @@ -0,0 +1,63 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigReceiverEmailConfig + { + /// + /// SMTP authentication information. Must be a valid email address + /// + public readonly string? AuthIdentity; + /// + /// SMTP authentication password. + /// + public readonly string? AuthPassword; + /// + /// SMTP authentication username. + /// + public readonly string? AuthUsername; + /// + /// The sender email address. Must be a valid email address + /// + public readonly string? From; + /// + /// The SMTP host through which emails are sent. + /// + public readonly string? SmartHost; + /// + /// The email address to send notifications to. Must be a valid email address + /// + public readonly string? To; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigReceiverEmailConfig( + string? authIdentity, + + string? authPassword, + + string? authUsername, + + string? from, + + string? smartHost, + + string? to) + { + AuthIdentity = authIdentity; + AuthPassword = authPassword; + AuthUsername = authUsername; + From = from; + SmartHost = smartHost; + To = to; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfig.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfig.cs new file mode 100644 index 0000000..695e73f --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverOpsgenieConfig.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigReceiverOpsgenieConfig + { + /// + /// The API key for OpsGenie. + /// + public readonly string? ApiKey; + /// + /// The host to send OpsGenie API requests to. Must be a valid URL + /// + public readonly string? ApiUrl; + /// + /// Comma separated list of tags attached to the notifications. + /// + public readonly string? Tags; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigReceiverOpsgenieConfig( + string? apiKey, + + string? apiUrl, + + string? tags) + { + ApiKey = apiKey; + ApiUrl = apiUrl; + Tags = tags; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfig.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfig.cs new file mode 100644 index 0000000..48798c8 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigReceiverWebhooksConfig.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigReceiverWebhooksConfig + { + /// + /// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + /// + public readonly bool? MsTeams; + /// + /// The endpoint to send HTTP POST requests to. Must be a valid URL + /// + public readonly string? Url; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigReceiverWebhooksConfig( + bool? msTeams, + + string? url) + { + MsTeams = msTeams; + Url = url; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRoute.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRoute.cs new file mode 100644 index 0000000..05f7ba6 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRoute.cs @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigRoute + { + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public readonly ImmutableArray GroupBies; + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + public readonly string? GroupInterval; + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + public readonly string? GroupWait; + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary? Match; + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary? MatchRegex; + /// + /// The name of the receiver to route the alerts to. + /// + public readonly string Receiver; + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + public readonly string? RepeatInterval; + /// + /// List of child routes. + /// + public readonly ImmutableArray Routes; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigRoute( + ImmutableArray groupBies, + + string? groupInterval, + + string? groupWait, + + ImmutableDictionary? match, + + ImmutableDictionary? matchRegex, + + string receiver, + + string? repeatInterval, + + ImmutableArray routes) + { + GroupBies = groupBies; + GroupInterval = groupInterval; + GroupWait = groupWait; + Match = match; + MatchRegex = matchRegex; + Receiver = receiver; + RepeatInterval = repeatInterval; + Routes = routes; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRouteRoute.cs b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRouteRoute.cs new file mode 100644 index 0000000..42ccf44 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityInstanceAlertConfigRouteRoute.cs @@ -0,0 +1,70 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityInstanceAlertConfigRouteRoute + { + /// + /// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + /// + public readonly ImmutableArray GroupBies; + /// + /// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + /// + public readonly string? GroupInterval; + /// + /// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + /// + public readonly string? GroupWait; + /// + /// A set of equality matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary? Match; + /// + /// A set of regex-matchers an alert has to fulfill to match the node. + /// + public readonly ImmutableDictionary? MatchRegex; + /// + /// The name of the receiver to route the alerts to. + /// + public readonly string Receiver; + /// + /// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + /// + public readonly string? RepeatInterval; + + [OutputConstructor] + private ObservabilityInstanceAlertConfigRouteRoute( + ImmutableArray groupBies, + + string? groupInterval, + + string? groupWait, + + ImmutableDictionary? match, + + ImmutableDictionary? matchRegex, + + string receiver, + + string? repeatInterval) + { + GroupBies = groupBies; + GroupInterval = groupInterval; + GroupWait = groupWait; + Match = match; + MatchRegex = matchRegex; + Receiver = receiver; + RepeatInterval = repeatInterval; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityLogalertgroupRule.cs b/sdk/dotnet/Outputs/ObservabilityLogalertgroupRule.cs new file mode 100644 index 0000000..edacd10 --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityLogalertgroupRule.cs @@ -0,0 +1,56 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityLogalertgroupRule + { + /// + /// The name of the alert rule. Is the identifier and must be unique in the group. + /// + public readonly string Alert; + /// + /// A map of key:value. Annotations to add or overwrite for each alert + /// + public readonly ImmutableDictionary? Annotations; + /// + /// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + /// + public readonly string Expression; + /// + /// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + /// + public readonly string? For; + /// + /// A map of key:value. Labels to add or overwrite for each alert + /// + public readonly ImmutableDictionary? Labels; + + [OutputConstructor] + private ObservabilityLogalertgroupRule( + string alert, + + ImmutableDictionary? annotations, + + string expression, + + string? @for, + + ImmutableDictionary? labels) + { + Alert = alert; + Annotations = annotations; + Expression = expression; + For = @for; + Labels = labels; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityScrapeconfigBasicAuth.cs b/sdk/dotnet/Outputs/ObservabilityScrapeconfigBasicAuth.cs new file mode 100644 index 0000000..cbb2b4e --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityScrapeconfigBasicAuth.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityScrapeconfigBasicAuth + { + /// + /// Specifies basic auth password. + /// + public readonly string Password; + /// + /// Specifies basic auth username. + /// + public readonly string Username; + + [OutputConstructor] + private ObservabilityScrapeconfigBasicAuth( + string password, + + string username) + { + Password = password; + Username = username; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityScrapeconfigSaml2.cs b/sdk/dotnet/Outputs/ObservabilityScrapeconfigSaml2.cs new file mode 100644 index 0000000..2cd9bfb --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityScrapeconfigSaml2.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityScrapeconfigSaml2 + { + /// + /// Specifies if URL parameters are enabled. Defaults to `true` + /// + public readonly bool? EnableUrlParameters; + + [OutputConstructor] + private ObservabilityScrapeconfigSaml2(bool? enableUrlParameters) + { + EnableUrlParameters = enableUrlParameters; + } + } +} diff --git a/sdk/dotnet/Outputs/ObservabilityScrapeconfigTarget.cs b/sdk/dotnet/Outputs/ObservabilityScrapeconfigTarget.cs new file mode 100644 index 0000000..eb8f59e --- /dev/null +++ b/sdk/dotnet/Outputs/ObservabilityScrapeconfigTarget.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ObservabilityScrapeconfigTarget + { + /// + /// Specifies labels. + /// + public readonly ImmutableDictionary? Labels; + /// + /// Specifies target URLs. + /// + public readonly ImmutableArray Urls; + + [OutputConstructor] + private ObservabilityScrapeconfigTarget( + ImmutableDictionary? labels, + + ImmutableArray urls) + { + Labels = labels; + Urls = urls; + } + } +} diff --git a/sdk/dotnet/Outputs/OpensearchInstanceParameters.cs b/sdk/dotnet/Outputs/OpensearchInstanceParameters.cs new file mode 100644 index 0000000..37f2d4b --- /dev/null +++ b/sdk/dotnet/Outputs/OpensearchInstanceParameters.cs @@ -0,0 +1,119 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class OpensearchInstanceParameters + { + /// + /// Enable monitoring. + /// + public readonly bool? EnableMonitoring; + /// + /// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + /// + public readonly string? Graphite; + /// + /// The garbage collector to use for OpenSearch. + /// + public readonly string? JavaGarbageCollector; + /// + /// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + /// + public readonly int? JavaHeapspace; + /// + /// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + /// + public readonly int? JavaMaxmetaspace; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int? MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted (in seconds). + /// + public readonly int? MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + /// + public readonly string? MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string? MonitoringInstanceId; + /// + /// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + /// + public readonly ImmutableArray Plugins; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string? SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// The TLS protocol to use. + /// + public readonly string? TlsProtocols; + + [OutputConstructor] + private OpensearchInstanceParameters( + bool? enableMonitoring, + + string? graphite, + + string? javaGarbageCollector, + + int? javaHeapspace, + + int? javaMaxmetaspace, + + int? maxDiskThreshold, + + int? metricsFrequency, + + string? metricsPrefix, + + string? monitoringInstanceId, + + ImmutableArray plugins, + + string? sgwAcl, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string? tlsProtocols) + { + EnableMonitoring = enableMonitoring; + Graphite = graphite; + JavaGarbageCollector = javaGarbageCollector; + JavaHeapspace = javaHeapspace; + JavaMaxmetaspace = javaMaxmetaspace; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + Plugins = plugins; + SgwAcl = sgwAcl; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/PostgresflexInstanceFlavor.cs b/sdk/dotnet/Outputs/PostgresflexInstanceFlavor.cs new file mode 100644 index 0000000..c2ca82a --- /dev/null +++ b/sdk/dotnet/Outputs/PostgresflexInstanceFlavor.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class PostgresflexInstanceFlavor + { + public readonly int Cpu; + public readonly string? Description; + public readonly string? Id; + public readonly int Ram; + + [OutputConstructor] + private PostgresflexInstanceFlavor( + int cpu, + + string? description, + + string? id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/PostgresflexInstanceStorage.cs b/sdk/dotnet/Outputs/PostgresflexInstanceStorage.cs new file mode 100644 index 0000000..c03ffe3 --- /dev/null +++ b/sdk/dotnet/Outputs/PostgresflexInstanceStorage.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class PostgresflexInstanceStorage + { + public readonly string Class; + public readonly int Size; + + [OutputConstructor] + private PostgresflexInstanceStorage( + string @class, + + int size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/RabbitmqInstanceParameters.cs b/sdk/dotnet/Outputs/RabbitmqInstanceParameters.cs new file mode 100644 index 0000000..ad4867e --- /dev/null +++ b/sdk/dotnet/Outputs/RabbitmqInstanceParameters.cs @@ -0,0 +1,112 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class RabbitmqInstanceParameters + { + /// + /// The timeout in milliseconds for the consumer. + /// + public readonly int? ConsumerTimeout; + /// + /// Enable monitoring. + /// + public readonly bool? EnableMonitoring; + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + public readonly string? Graphite; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int? MaxDiskThreshold; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int? MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string? MetricsPrefix; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string? MonitoringInstanceId; + /// + /// List of plugins to install. Must be a supported plugin name. + /// + public readonly ImmutableArray Plugins; + /// + /// List of roles to assign to the instance. + /// + public readonly ImmutableArray Roles; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string? SgwAcl; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// TLS protocol to use. + /// + public readonly string? TlsProtocols; + + [OutputConstructor] + private RabbitmqInstanceParameters( + int? consumerTimeout, + + bool? enableMonitoring, + + string? graphite, + + int? maxDiskThreshold, + + int? metricsFrequency, + + string? metricsPrefix, + + string? monitoringInstanceId, + + ImmutableArray plugins, + + ImmutableArray roles, + + string? sgwAcl, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string? tlsProtocols) + { + ConsumerTimeout = consumerTimeout; + EnableMonitoring = enableMonitoring; + Graphite = graphite; + MaxDiskThreshold = maxDiskThreshold; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MonitoringInstanceId = monitoringInstanceId; + Plugins = plugins; + Roles = roles; + SgwAcl = sgwAcl; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/RedisInstanceParameters.cs b/sdk/dotnet/Outputs/RedisInstanceParameters.cs new file mode 100644 index 0000000..70707f1 --- /dev/null +++ b/sdk/dotnet/Outputs/RedisInstanceParameters.cs @@ -0,0 +1,175 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class RedisInstanceParameters + { + /// + /// The number of milliseconds after which the instance is considered down. + /// + public readonly int? DownAfterMilliseconds; + /// + /// Enable monitoring. + /// + public readonly bool? EnableMonitoring; + /// + /// The failover timeout in milliseconds. + /// + public readonly int? FailoverTimeout; + /// + /// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + /// + public readonly string? Graphite; + /// + /// The lazy eviction enablement (yes or no). + /// + public readonly string? LazyfreeLazyEviction; + /// + /// The lazy expire enablement (yes or no). + /// + public readonly string? LazyfreeLazyExpire; + /// + /// The Lua time limit. + /// + public readonly int? LuaTimeLimit; + /// + /// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + /// + public readonly int? MaxDiskThreshold; + /// + /// The maximum number of clients. + /// + public readonly int? Maxclients; + /// + /// The policy to handle the maximum memory (volatile-lru, noeviction, etc). + /// + public readonly string? MaxmemoryPolicy; + /// + /// The maximum memory samples. + /// + public readonly int? MaxmemorySamples; + /// + /// The frequency in seconds at which metrics are emitted. + /// + public readonly int? MetricsFrequency; + /// + /// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + /// + public readonly string? MetricsPrefix; + /// + /// The minimum replicas maximum lag. + /// + public readonly int? MinReplicasMaxLag; + /// + /// The ID of the STACKIT monitoring instance. + /// + public readonly string? MonitoringInstanceId; + /// + /// The notify keyspace events. + /// + public readonly string? NotifyKeyspaceEvents; + /// + /// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + /// + public readonly string? SgwAcl; + /// + /// The snapshot configuration. + /// + public readonly string? Snapshot; + /// + /// List of syslog servers to send logs to. + /// + public readonly ImmutableArray Syslogs; + /// + /// List of TLS ciphers to use. + /// + public readonly ImmutableArray TlsCiphers; + /// + /// TLS cipher suites to use. + /// + public readonly string? TlsCiphersuites; + /// + /// TLS protocol to use. + /// + public readonly string? TlsProtocols; + + [OutputConstructor] + private RedisInstanceParameters( + int? downAfterMilliseconds, + + bool? enableMonitoring, + + int? failoverTimeout, + + string? graphite, + + string? lazyfreeLazyEviction, + + string? lazyfreeLazyExpire, + + int? luaTimeLimit, + + int? maxDiskThreshold, + + int? maxclients, + + string? maxmemoryPolicy, + + int? maxmemorySamples, + + int? metricsFrequency, + + string? metricsPrefix, + + int? minReplicasMaxLag, + + string? monitoringInstanceId, + + string? notifyKeyspaceEvents, + + string? sgwAcl, + + string? snapshot, + + ImmutableArray syslogs, + + ImmutableArray tlsCiphers, + + string? tlsCiphersuites, + + string? tlsProtocols) + { + DownAfterMilliseconds = downAfterMilliseconds; + EnableMonitoring = enableMonitoring; + FailoverTimeout = failoverTimeout; + Graphite = graphite; + LazyfreeLazyEviction = lazyfreeLazyEviction; + LazyfreeLazyExpire = lazyfreeLazyExpire; + LuaTimeLimit = luaTimeLimit; + MaxDiskThreshold = maxDiskThreshold; + Maxclients = maxclients; + MaxmemoryPolicy = maxmemoryPolicy; + MaxmemorySamples = maxmemorySamples; + MetricsFrequency = metricsFrequency; + MetricsPrefix = metricsPrefix; + MinReplicasMaxLag = minReplicasMaxLag; + MonitoringInstanceId = monitoringInstanceId; + NotifyKeyspaceEvents = notifyKeyspaceEvents; + SgwAcl = sgwAcl; + Snapshot = snapshot; + Syslogs = syslogs; + TlsCiphers = tlsCiphers; + TlsCiphersuites = tlsCiphersuites; + TlsProtocols = tlsProtocols; + } + } +} diff --git a/sdk/dotnet/Outputs/SecurityGroupRuleIcmpParameters.cs b/sdk/dotnet/Outputs/SecurityGroupRuleIcmpParameters.cs new file mode 100644 index 0000000..84dc46d --- /dev/null +++ b/sdk/dotnet/Outputs/SecurityGroupRuleIcmpParameters.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SecurityGroupRuleIcmpParameters + { + /// + /// ICMP code. Can be set if the protocol is ICMP. + /// + public readonly int Code; + /// + /// ICMP type. Can be set if the protocol is ICMP. + /// + public readonly int Type; + + [OutputConstructor] + private SecurityGroupRuleIcmpParameters( + int code, + + int type) + { + Code = code; + Type = type; + } + } +} diff --git a/sdk/dotnet/Outputs/SecurityGroupRulePortRange.cs b/sdk/dotnet/Outputs/SecurityGroupRulePortRange.cs new file mode 100644 index 0000000..f6506e4 --- /dev/null +++ b/sdk/dotnet/Outputs/SecurityGroupRulePortRange.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SecurityGroupRulePortRange + { + /// + /// The maximum port number. Should be greater or equal to the minimum. + /// + public readonly int Max; + /// + /// The minimum port number. Should be less or equal to the maximum. + /// + public readonly int Min; + + [OutputConstructor] + private SecurityGroupRulePortRange( + int max, + + int min) + { + Max = max; + Min = min; + } + } +} diff --git a/sdk/dotnet/Outputs/SecurityGroupRuleProtocol.cs b/sdk/dotnet/Outputs/SecurityGroupRuleProtocol.cs new file mode 100644 index 0000000..a62fe00 --- /dev/null +++ b/sdk/dotnet/Outputs/SecurityGroupRuleProtocol.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SecurityGroupRuleProtocol + { + /// + /// The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + /// + public readonly string? Name; + /// + /// The protocol number which the rule should match. Either `name` or `number` must be provided. + /// + public readonly int? Number; + + [OutputConstructor] + private SecurityGroupRuleProtocol( + string? name, + + int? number) + { + Name = name; + Number = number; + } + } +} diff --git a/sdk/dotnet/Outputs/ServerBackupScheduleBackupProperties.cs b/sdk/dotnet/Outputs/ServerBackupScheduleBackupProperties.cs new file mode 100644 index 0000000..f21889f --- /dev/null +++ b/sdk/dotnet/Outputs/ServerBackupScheduleBackupProperties.cs @@ -0,0 +1,33 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ServerBackupScheduleBackupProperties + { + public readonly string Name; + public readonly int RetentionPeriod; + public readonly ImmutableArray VolumeIds; + + [OutputConstructor] + private ServerBackupScheduleBackupProperties( + string name, + + int retentionPeriod, + + ImmutableArray volumeIds) + { + Name = name; + RetentionPeriod = retentionPeriod; + VolumeIds = volumeIds; + } + } +} diff --git a/sdk/dotnet/Outputs/ServerBootVolume.cs b/sdk/dotnet/Outputs/ServerBootVolume.cs new file mode 100644 index 0000000..83a058b --- /dev/null +++ b/sdk/dotnet/Outputs/ServerBootVolume.cs @@ -0,0 +1,63 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class ServerBootVolume + { + /// + /// Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + /// + public readonly bool? DeleteOnTermination; + /// + /// The ID of the boot volume + /// + public readonly string? Id; + /// + /// The performance class of the server. + /// + public readonly string? PerformanceClass; + /// + /// The size of the boot volume in GB. Must be provided when `source_type` is `image`. + /// + public readonly int? Size; + /// + /// The ID of the source, either image ID or volume ID + /// + public readonly string SourceId; + /// + /// The type of the source. Supported values are: `volume`, `image`. + /// + public readonly string SourceType; + + [OutputConstructor] + private ServerBootVolume( + bool? deleteOnTermination, + + string? id, + + string? performanceClass, + + int? size, + + string sourceId, + + string sourceType) + { + DeleteOnTermination = deleteOnTermination; + Id = id; + PerformanceClass = performanceClass; + Size = size; + SourceId = sourceId; + SourceType = sourceType; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterExtensions.cs b/sdk/dotnet/Outputs/SkeClusterExtensions.cs new file mode 100644 index 0000000..8a27b6a --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterExtensions.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterExtensions + { + /// + /// Cluster access control configuration. + /// + public readonly Outputs.SkeClusterExtensionsAcl? Acl; + /// + /// A single argus block as defined below. + /// + public readonly Outputs.SkeClusterExtensionsArgus? Argus; + /// + /// DNS extension configuration + /// + public readonly Outputs.SkeClusterExtensionsDns? Dns; + + [OutputConstructor] + private SkeClusterExtensions( + Outputs.SkeClusterExtensionsAcl? acl, + + Outputs.SkeClusterExtensionsArgus? argus, + + Outputs.SkeClusterExtensionsDns? dns) + { + Acl = acl; + Argus = argus; + Dns = dns; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterExtensionsAcl.cs b/sdk/dotnet/Outputs/SkeClusterExtensionsAcl.cs new file mode 100644 index 0000000..ca8e2d9 --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterExtensionsAcl.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterExtensionsAcl + { + /// + /// Specify a list of CIDRs to whitelist. + /// + public readonly ImmutableArray AllowedCidrs; + /// + /// Is ACL enabled? + /// + public readonly bool Enabled; + + [OutputConstructor] + private SkeClusterExtensionsAcl( + ImmutableArray allowedCidrs, + + bool enabled) + { + AllowedCidrs = allowedCidrs; + Enabled = enabled; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterExtensionsArgus.cs b/sdk/dotnet/Outputs/SkeClusterExtensionsArgus.cs new file mode 100644 index 0000000..638e219 --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterExtensionsArgus.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterExtensionsArgus + { + /// + /// Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + /// + public readonly string? ArgusInstanceId; + /// + /// Flag to enable/disable Argus extensions. + /// + public readonly bool Enabled; + + [OutputConstructor] + private SkeClusterExtensionsArgus( + string? argusInstanceId, + + bool enabled) + { + ArgusInstanceId = argusInstanceId; + Enabled = enabled; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterExtensionsDns.cs b/sdk/dotnet/Outputs/SkeClusterExtensionsDns.cs new file mode 100644 index 0000000..bf515ce --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterExtensionsDns.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterExtensionsDns + { + /// + /// Flag to enable/disable DNS extensions + /// + public readonly bool Enabled; + /// + /// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + /// + public readonly ImmutableArray Zones; + + [OutputConstructor] + private SkeClusterExtensionsDns( + bool enabled, + + ImmutableArray zones) + { + Enabled = enabled; + Zones = zones; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterHibernation.cs b/sdk/dotnet/Outputs/SkeClusterHibernation.cs new file mode 100644 index 0000000..ab0e852 --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterHibernation.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterHibernation + { + /// + /// End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + /// + public readonly string End; + /// + /// Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + /// + public readonly string Start; + /// + /// Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + /// + public readonly string? Timezone; + + [OutputConstructor] + private SkeClusterHibernation( + string end, + + string start, + + string? timezone) + { + End = end; + Start = start; + Timezone = timezone; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterMaintenance.cs b/sdk/dotnet/Outputs/SkeClusterMaintenance.cs new file mode 100644 index 0000000..9070caa --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterMaintenance.cs @@ -0,0 +1,49 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterMaintenance + { + /// + /// Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + public readonly bool? EnableKubernetesVersionUpdates; + /// + /// Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + public readonly bool? EnableMachineImageVersionUpdates; + /// + /// Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + public readonly string End; + /// + /// Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + /// + public readonly string Start; + + [OutputConstructor] + private SkeClusterMaintenance( + bool? enableKubernetesVersionUpdates, + + bool? enableMachineImageVersionUpdates, + + string end, + + string start) + { + EnableKubernetesVersionUpdates = enableKubernetesVersionUpdates; + EnableMachineImageVersionUpdates = enableMachineImageVersionUpdates; + End = end; + Start = start; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterNetwork.cs b/sdk/dotnet/Outputs/SkeClusterNetwork.cs new file mode 100644 index 0000000..cc2b44b --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterNetwork.cs @@ -0,0 +1,27 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterNetwork + { + /// + /// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + /// + public readonly string? Id; + + [OutputConstructor] + private SkeClusterNetwork(string? id) + { + Id = id; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterNodePool.cs b/sdk/dotnet/Outputs/SkeClusterNodePool.cs new file mode 100644 index 0000000..30e27c7 --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterNodePool.cs @@ -0,0 +1,140 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterNodePool + { + /// + /// Allow system components to run on this node pool. + /// + public readonly bool? AllowSystemComponents; + /// + /// Specify a list of availability zones. E.g. `eu01-m` + /// + public readonly ImmutableArray AvailabilityZones; + /// + /// Specifies the container runtime. Defaults to `containerd` + /// + public readonly string? Cri; + /// + /// Labels to add to each node. + /// + public readonly ImmutableDictionary? Labels; + /// + /// The machine type. + /// + public readonly string MachineType; + /// + /// Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + public readonly int? MaxSurge; + /// + /// Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + /// + public readonly int? MaxUnavailable; + /// + /// Maximum number of nodes in the pool. + /// + public readonly int Maximum; + /// + /// Minimum number of nodes in the pool. + /// + public readonly int Minimum; + /// + /// Specifies the name of the node pool. + /// + public readonly string Name; + /// + /// The name of the OS image. Defaults to `flatcar`. + /// + public readonly string? OsName; + /// + /// This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + /// + public readonly string? OsVersion; + /// + /// The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + /// + public readonly string? OsVersionMin; + /// + /// Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + public readonly string? OsVersionUsed; + /// + /// Specifies a taint list as defined below. + /// + public readonly ImmutableArray Taints; + /// + /// The volume size in GB. Defaults to `20` + /// + public readonly int? VolumeSize; + /// + /// Specifies the volume type. Defaults to `storage_premium_perf1`. + /// + public readonly string? VolumeType; + + [OutputConstructor] + private SkeClusterNodePool( + bool? allowSystemComponents, + + ImmutableArray availabilityZones, + + string? cri, + + ImmutableDictionary? labels, + + string machineType, + + int? maxSurge, + + int? maxUnavailable, + + int maximum, + + int minimum, + + string name, + + string? osName, + + string? osVersion, + + string? osVersionMin, + + string? osVersionUsed, + + ImmutableArray taints, + + int? volumeSize, + + string? volumeType) + { + AllowSystemComponents = allowSystemComponents; + AvailabilityZones = availabilityZones; + Cri = cri; + Labels = labels; + MachineType = machineType; + MaxSurge = maxSurge; + MaxUnavailable = maxUnavailable; + Maximum = maximum; + Minimum = minimum; + Name = name; + OsName = osName; + OsVersion = osVersion; + OsVersionMin = osVersionMin; + OsVersionUsed = osVersionUsed; + Taints = taints; + VolumeSize = volumeSize; + VolumeType = volumeType; + } + } +} diff --git a/sdk/dotnet/Outputs/SkeClusterNodePoolTaint.cs b/sdk/dotnet/Outputs/SkeClusterNodePoolTaint.cs new file mode 100644 index 0000000..45320e3 --- /dev/null +++ b/sdk/dotnet/Outputs/SkeClusterNodePoolTaint.cs @@ -0,0 +1,42 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SkeClusterNodePoolTaint + { + /// + /// The taint effect. E.g `PreferNoSchedule`. + /// + public readonly string Effect; + /// + /// Taint key to be applied to a node. + /// + public readonly string Key; + /// + /// Taint value corresponding to the taint key. + /// + public readonly string? Value; + + [OutputConstructor] + private SkeClusterNodePoolTaint( + string effect, + + string key, + + string? value) + { + Effect = effect; + Key = key; + Value = value; + } + } +} diff --git a/sdk/dotnet/Outputs/SqlserverflexInstanceFlavor.cs b/sdk/dotnet/Outputs/SqlserverflexInstanceFlavor.cs new file mode 100644 index 0000000..e1dc176 --- /dev/null +++ b/sdk/dotnet/Outputs/SqlserverflexInstanceFlavor.cs @@ -0,0 +1,37 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SqlserverflexInstanceFlavor + { + public readonly int Cpu; + public readonly string? Description; + public readonly string? Id; + public readonly int Ram; + + [OutputConstructor] + private SqlserverflexInstanceFlavor( + int cpu, + + string? description, + + string? id, + + int ram) + { + Cpu = cpu; + Description = description; + Id = id; + Ram = ram; + } + } +} diff --git a/sdk/dotnet/Outputs/SqlserverflexInstanceOptions.cs b/sdk/dotnet/Outputs/SqlserverflexInstanceOptions.cs new file mode 100644 index 0000000..50ed4a0 --- /dev/null +++ b/sdk/dotnet/Outputs/SqlserverflexInstanceOptions.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SqlserverflexInstanceOptions + { + public readonly string? Edition; + public readonly int? RetentionDays; + + [OutputConstructor] + private SqlserverflexInstanceOptions( + string? edition, + + int? retentionDays) + { + Edition = edition; + RetentionDays = retentionDays; + } + } +} diff --git a/sdk/dotnet/Outputs/SqlserverflexInstanceStorage.cs b/sdk/dotnet/Outputs/SqlserverflexInstanceStorage.cs new file mode 100644 index 0000000..d8106b1 --- /dev/null +++ b/sdk/dotnet/Outputs/SqlserverflexInstanceStorage.cs @@ -0,0 +1,29 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class SqlserverflexInstanceStorage + { + public readonly string? Class; + public readonly int? Size; + + [OutputConstructor] + private SqlserverflexInstanceStorage( + string? @class, + + int? size) + { + Class = @class; + Size = size; + } + } +} diff --git a/sdk/dotnet/Outputs/VolumeSource.cs b/sdk/dotnet/Outputs/VolumeSource.cs new file mode 100644 index 0000000..2a752d5 --- /dev/null +++ b/sdk/dotnet/Outputs/VolumeSource.cs @@ -0,0 +1,35 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit.Outputs +{ + + [OutputType] + public sealed class VolumeSource + { + /// + /// The ID of the source, e.g. image ID + /// + public readonly string Id; + /// + /// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + /// + public readonly string Type; + + [OutputConstructor] + private VolumeSource( + string id, + + string type) + { + Id = id; + Type = type; + } + } +} diff --git a/sdk/dotnet/PostgresflexDatabase.cs b/sdk/dotnet/PostgresflexDatabase.cs new file mode 100644 index 0000000..27c2cb9 --- /dev/null +++ b/sdk/dotnet/PostgresflexDatabase.cs @@ -0,0 +1,182 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/postgresflexDatabase:PostgresflexDatabase")] + public partial class PostgresflexDatabase : global::Pulumi.CustomResource + { + /// + /// Database ID. + /// + [Output("databaseId")] + public Output DatabaseId { get; private set; } = null!; + + /// + /// ID of the Postgres Flex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Database name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// Username of the database owner. + /// + [Output("owner")] + public Output Owner { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + + /// + /// Create a PostgresflexDatabase 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 PostgresflexDatabase(string name, PostgresflexDatabaseArgs args, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexDatabase:PostgresflexDatabase", name, args ?? new PostgresflexDatabaseArgs(), MakeResourceOptions(options, "")) + { + } + + private PostgresflexDatabase(string name, Input id, PostgresflexDatabaseState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexDatabase:PostgresflexDatabase", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 PostgresflexDatabase 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 PostgresflexDatabase Get(string name, Input id, PostgresflexDatabaseState? state = null, CustomResourceOptions? options = null) + { + return new PostgresflexDatabase(name, id, state, options); + } + } + + public sealed class PostgresflexDatabaseArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the Postgres Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// Database name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Username of the database owner. + /// + [Input("owner", required: true)] + public Input Owner { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public PostgresflexDatabaseArgs() + { + } + public static new PostgresflexDatabaseArgs Empty => new PostgresflexDatabaseArgs(); + } + + public sealed class PostgresflexDatabaseState : global::Pulumi.ResourceArgs + { + /// + /// Database ID. + /// + [Input("databaseId")] + public Input? DatabaseId { get; set; } + + /// + /// ID of the Postgres Flex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Database name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Username of the database owner. + /// + [Input("owner")] + public Input? Owner { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public PostgresflexDatabaseState() + { + } + public static new PostgresflexDatabaseState Empty => new PostgresflexDatabaseState(); + } +} diff --git a/sdk/dotnet/PostgresflexInstance.cs b/sdk/dotnet/PostgresflexInstance.cs new file mode 100644 index 0000000..c1e02d8 --- /dev/null +++ b/sdk/dotnet/PostgresflexInstance.cs @@ -0,0 +1,221 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/postgresflexInstance:PostgresflexInstance")] + public partial class PostgresflexInstance : global::Pulumi.CustomResource + { + /// + /// The Access Control List (ACL) for the PostgresFlex instance. + /// + [Output("acls")] + public Output> Acls { get; private set; } = null!; + + [Output("backupSchedule")] + public Output BackupSchedule { get; private set; } = null!; + + [Output("flavor")] + public Output Flavor { get; private set; } = null!; + + /// + /// ID of the PostgresFlex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + [Output("replicas")] + public Output Replicas { get; private set; } = null!; + + [Output("storage")] + public Output Storage { get; private set; } = null!; + + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a PostgresflexInstance 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 PostgresflexInstance(string name, PostgresflexInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexInstance:PostgresflexInstance", name, args ?? new PostgresflexInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private PostgresflexInstance(string name, Input id, PostgresflexInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexInstance:PostgresflexInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 PostgresflexInstance 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 PostgresflexInstance Get(string name, Input id, PostgresflexInstanceState? state = null, CustomResourceOptions? options = null) + { + return new PostgresflexInstance(name, id, state, options); + } + } + + public sealed class PostgresflexInstanceArgs : global::Pulumi.ResourceArgs + { + [Input("acls", required: true)] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the PostgresFlex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + [Input("backupSchedule", required: true)] + public Input BackupSchedule { get; set; } = null!; + + [Input("flavor", required: true)] + public Input Flavor { get; set; } = null!; + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("replicas", required: true)] + public Input Replicas { get; set; } = null!; + + [Input("storage", required: true)] + public Input Storage { get; set; } = null!; + + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public PostgresflexInstanceArgs() + { + } + public static new PostgresflexInstanceArgs Empty => new PostgresflexInstanceArgs(); + } + + public sealed class PostgresflexInstanceState : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the PostgresFlex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + [Input("backupSchedule")] + public Input? BackupSchedule { get; set; } + + [Input("flavor")] + public Input? Flavor { get; set; } + + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("replicas")] + public Input? Replicas { get; set; } + + [Input("storage")] + public Input? Storage { get; set; } + + [Input("version")] + public Input? Version { get; set; } + + public PostgresflexInstanceState() + { + } + public static new PostgresflexInstanceState Empty => new PostgresflexInstanceState(); + } +} diff --git a/sdk/dotnet/PostgresflexUser.cs b/sdk/dotnet/PostgresflexUser.cs new file mode 100644 index 0000000..9b16c4c --- /dev/null +++ b/sdk/dotnet/PostgresflexUser.cs @@ -0,0 +1,232 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Postgres Flex user resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/postgresflexUser:PostgresflexUser")] + public partial class PostgresflexUser : global::Pulumi.CustomResource + { + [Output("host")] + public Output Host { get; private set; } = null!; + + /// + /// ID of the PostgresFlex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Database access levels for the user. Supported values are: `login`, `createdb`. + /// + [Output("roles")] + public Output> Roles { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + /// + /// User ID. + /// + [Output("userId")] + public Output UserId { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a PostgresflexUser 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 PostgresflexUser(string name, PostgresflexUserArgs args, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexUser:PostgresflexUser", name, args ?? new PostgresflexUserArgs(), MakeResourceOptions(options, "")) + { + } + + private PostgresflexUser(string name, Input id, PostgresflexUserState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/postgresflexUser:PostgresflexUser", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 PostgresflexUser 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 PostgresflexUser Get(string name, Input id, PostgresflexUserState? state = null, CustomResourceOptions? options = null) + { + return new PostgresflexUser(name, id, state, options); + } + } + + public sealed class PostgresflexUserArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("roles", required: true)] + private InputList? _roles; + + /// + /// Database access levels for the user. Supported values are: `login`, `createdb`. + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public PostgresflexUserArgs() + { + } + public static new PostgresflexUserArgs Empty => new PostgresflexUserArgs(); + } + + public sealed class PostgresflexUserState : global::Pulumi.ResourceArgs + { + [Input("host")] + public Input? Host { get; set; } + + /// + /// ID of the PostgresFlex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("roles")] + private InputList? _roles; + + /// + /// Database access levels for the user. Supported values are: `login`, `createdb`. + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// User ID. + /// + [Input("userId")] + public Input? UserId { get; set; } + + [Input("username")] + public Input? Username { get; set; } + + public PostgresflexUserState() + { + } + public static new PostgresflexUserState Empty => new PostgresflexUserState(); + } +} diff --git a/sdk/dotnet/Provider.cs b/sdk/dotnet/Provider.cs new file mode 100644 index 0000000..ff074fa --- /dev/null +++ b/sdk/dotnet/Provider.cs @@ -0,0 +1,525 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// The provider type for the stackit package. By default, resources use package-wide configuration + /// settings, however an explicit `Provider` instance may be created and passed during resource + /// construction to achieve fine-grained programmatic control over provider settings. See the + /// [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + /// + [StackitResourceType("pulumi:providers:stackit")] + public partial class Provider : global::Pulumi.ProviderResource + { + /// + /// Custom endpoint for the Argus service + /// + [Output("argusCustomEndpoint")] + public Output ArgusCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Membership service + /// + [Output("authorizationCustomEndpoint")] + public Output AuthorizationCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the CDN service + /// + [Output("cdnCustomEndpoint")] + public Output CdnCustomEndpoint { get; private set; } = null!; + + /// + /// Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + /// value is `~/.stackit/credentials.json`. + /// + [Output("credentialsPath")] + public Output CredentialsPath { get; private set; } = null!; + + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + [Output("defaultRegion")] + public Output DefaultRegion { get; private set; } = null!; + + /// + /// Custom endpoint for the DNS service + /// + [Output("dnsCustomEndpoint")] + public Output DnsCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Git service + /// + [Output("gitCustomEndpoint")] + public Output GitCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the IaaS service + /// + [Output("iaasCustomEndpoint")] + public Output IaasCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Load Balancer service + /// + [Output("loadbalancerCustomEndpoint")] + public Output LoadbalancerCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the LogMe service + /// + [Output("logmeCustomEndpoint")] + public Output LogmeCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the MariaDB service + /// + [Output("mariadbCustomEndpoint")] + public Output MariadbCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the AI Model Serving service + /// + [Output("modelservingCustomEndpoint")] + public Output ModelservingCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the MongoDB Flex service + /// + [Output("mongodbflexCustomEndpoint")] + public Output MongodbflexCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Object Storage service + /// + [Output("objectstorageCustomEndpoint")] + public Output ObjectstorageCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Observability service + /// + [Output("observabilityCustomEndpoint")] + public Output ObservabilityCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the OpenSearch service + /// + [Output("opensearchCustomEndpoint")] + public Output OpensearchCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the PostgresFlex service + /// + [Output("postgresflexCustomEndpoint")] + public Output PostgresflexCustomEndpoint { get; private set; } = null!; + + /// + /// Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + /// included in the service account key. + /// + [Output("privateKey")] + public Output PrivateKey { get; private set; } = null!; + + /// + /// Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + /// key that is included in the service account key. + /// + [Output("privateKeyPath")] + public Output PrivateKeyPath { get; private set; } = null!; + + /// + /// Custom endpoint for the RabbitMQ service + /// + [Output("rabbitmqCustomEndpoint")] + public Output RabbitmqCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Redis service + /// + [Output("redisCustomEndpoint")] + public Output RedisCustomEndpoint { get; private set; } = null!; + + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Custom endpoint for the Resource Manager service + /// + [Output("resourcemanagerCustomEndpoint")] + public Output ResourcemanagerCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Secrets Manager service + /// + [Output("secretsmanagerCustomEndpoint")] + public Output SecretsmanagerCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Server Backup service + /// + [Output("serverBackupCustomEndpoint")] + public Output ServerBackupCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Server Update service + /// + [Output("serverUpdateCustomEndpoint")] + public Output ServerUpdateCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Service Account service + /// + [Output("serviceAccountCustomEndpoint")] + public Output ServiceAccountCustomEndpoint { get; private set; } = null!; + + /// + /// Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + /// if you want to use the resource manager project resource. + /// + [Output("serviceAccountEmail")] + public Output ServiceAccountEmail { get; private set; } = null!; + + /// + /// Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + /// + [Output("serviceAccountKey")] + public Output ServiceAccountKey { get; private set; } = null!; + + /// + /// Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + /// operations. + /// + [Output("serviceAccountKeyPath")] + public Output ServiceAccountKeyPath { get; private set; } = null!; + + /// + /// Token used for authentication. If set, the token flow will be used to authenticate all operations. + /// + [Output("serviceAccountToken")] + public Output ServiceAccountToken { get; private set; } = null!; + + /// + /// Custom endpoint for the Service Enablement API + /// + [Output("serviceEnablementCustomEndpoint")] + public Output ServiceEnablementCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the Kubernetes Engine (SKE) service + /// + [Output("skeCustomEndpoint")] + public Output SkeCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the SQL Server Flex service + /// + [Output("sqlserverflexCustomEndpoint")] + public Output SqlserverflexCustomEndpoint { get; private set; } = null!; + + /// + /// Custom endpoint for the token API, which is used to request access tokens when using the key flow + /// + [Output("tokenCustomEndpoint")] + public Output TokenCustomEndpoint { get; private set; } = null!; + + + /// + /// Create a Provider 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 Provider(string name, ProviderArgs? args = null, CustomResourceOptions? options = null) + : base("stackit", name, args ?? new ProviderArgs(), MakeResourceOptions(options, "")) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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; + } + + /// + /// This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. + /// + public global::Pulumi.Output TerraformConfig() + => global::Pulumi.Deployment.Instance.Call("pulumi:providers:stackit/terraformConfig", CallArgs.Empty, this); + } + + public sealed class ProviderArgs : global::Pulumi.ResourceArgs + { + /// + /// Custom endpoint for the Argus service + /// + [Input("argusCustomEndpoint")] + public Input? ArgusCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Membership service + /// + [Input("authorizationCustomEndpoint")] + public Input? AuthorizationCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the CDN service + /// + [Input("cdnCustomEndpoint")] + public Input? CdnCustomEndpoint { get; set; } + + /// + /// Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + /// value is `~/.stackit/credentials.json`. + /// + [Input("credentialsPath")] + public Input? CredentialsPath { get; set; } + + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + [Input("defaultRegion")] + public Input? DefaultRegion { get; set; } + + /// + /// Custom endpoint for the DNS service + /// + [Input("dnsCustomEndpoint")] + public Input? DnsCustomEndpoint { get; set; } + + /// + /// Enable beta resources. Default is false. + /// + [Input("enableBetaResources", json: true)] + public Input? EnableBetaResources { get; set; } + + [Input("experiments", json: true)] + private InputList? _experiments; + + /// + /// Enables experiments. These are unstable features without official support. More information can be found in the README. + /// Available Experiments: [iam] + /// + public InputList Experiments + { + get => _experiments ?? (_experiments = new InputList()); + set => _experiments = value; + } + + /// + /// Custom endpoint for the Git service + /// + [Input("gitCustomEndpoint")] + public Input? GitCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the IaaS service + /// + [Input("iaasCustomEndpoint")] + public Input? IaasCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Load Balancer service + /// + [Input("loadbalancerCustomEndpoint")] + public Input? LoadbalancerCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the LogMe service + /// + [Input("logmeCustomEndpoint")] + public Input? LogmeCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the MariaDB service + /// + [Input("mariadbCustomEndpoint")] + public Input? MariadbCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the AI Model Serving service + /// + [Input("modelservingCustomEndpoint")] + public Input? ModelservingCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the MongoDB Flex service + /// + [Input("mongodbflexCustomEndpoint")] + public Input? MongodbflexCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Object Storage service + /// + [Input("objectstorageCustomEndpoint")] + public Input? ObjectstorageCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Observability service + /// + [Input("observabilityCustomEndpoint")] + public Input? ObservabilityCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the OpenSearch service + /// + [Input("opensearchCustomEndpoint")] + public Input? OpensearchCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the PostgresFlex service + /// + [Input("postgresflexCustomEndpoint")] + public Input? PostgresflexCustomEndpoint { get; set; } + + /// + /// Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + /// included in the service account key. + /// + [Input("privateKey")] + public Input? PrivateKey { get; set; } + + /// + /// Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + /// key that is included in the service account key. + /// + [Input("privateKeyPath")] + public Input? PrivateKeyPath { get; set; } + + /// + /// Custom endpoint for the RabbitMQ service + /// + [Input("rabbitmqCustomEndpoint")] + public Input? RabbitmqCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Redis service + /// + [Input("redisCustomEndpoint")] + public Input? RedisCustomEndpoint { get; set; } + + /// + /// Region will be used as the default location for regional services. Not all services require a region, some are global + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Custom endpoint for the Resource Manager service + /// + [Input("resourcemanagerCustomEndpoint")] + public Input? ResourcemanagerCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Secrets Manager service + /// + [Input("secretsmanagerCustomEndpoint")] + public Input? SecretsmanagerCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Server Backup service + /// + [Input("serverBackupCustomEndpoint")] + public Input? ServerBackupCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Server Update service + /// + [Input("serverUpdateCustomEndpoint")] + public Input? ServerUpdateCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Service Account service + /// + [Input("serviceAccountCustomEndpoint")] + public Input? ServiceAccountCustomEndpoint { get; set; } + + /// + /// Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + /// if you want to use the resource manager project resource. + /// + [Input("serviceAccountEmail")] + public Input? ServiceAccountEmail { get; set; } + + /// + /// Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + /// + [Input("serviceAccountKey")] + public Input? ServiceAccountKey { get; set; } + + /// + /// Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + /// operations. + /// + [Input("serviceAccountKeyPath")] + public Input? ServiceAccountKeyPath { get; set; } + + /// + /// Token used for authentication. If set, the token flow will be used to authenticate all operations. + /// + [Input("serviceAccountToken")] + public Input? ServiceAccountToken { get; set; } + + /// + /// Custom endpoint for the Service Enablement API + /// + [Input("serviceEnablementCustomEndpoint")] + public Input? ServiceEnablementCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the Kubernetes Engine (SKE) service + /// + [Input("skeCustomEndpoint")] + public Input? SkeCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the SQL Server Flex service + /// + [Input("sqlserverflexCustomEndpoint")] + public Input? SqlserverflexCustomEndpoint { get; set; } + + /// + /// Custom endpoint for the token API, which is used to request access tokens when using the key flow + /// + [Input("tokenCustomEndpoint")] + public Input? TokenCustomEndpoint { get; set; } + + public ProviderArgs() + { + } + public static new ProviderArgs Empty => new ProviderArgs(); + } + + /// + /// The results of the method. + /// + [OutputType] + public sealed class ProviderTerraformConfigResult + { + public readonly ImmutableDictionary Result; + + [OutputConstructor] + private ProviderTerraformConfigResult(ImmutableDictionary result) + { + Result = result; + } + } +} diff --git a/sdk/dotnet/PublicIp.cs b/sdk/dotnet/PublicIp.cs new file mode 100644 index 0000000..9e37bd5 --- /dev/null +++ b/sdk/dotnet/PublicIp.cs @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Public IP resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/publicIp:PublicIp")] + public partial class PublicIp : global::Pulumi.CustomResource + { + /// + /// The IP address. + /// + [Output("ip")] + public Output Ip { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + [Output("networkInterfaceId")] + public Output NetworkInterfaceId { get; private set; } = null!; + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The public IP ID. + /// + [Output("publicIpId")] + public Output PublicIpId { get; private set; } = null!; + + + /// + /// Create a PublicIp 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 PublicIp(string name, PublicIpArgs args, CustomResourceOptions? options = null) + : base("stackit:index/publicIp:PublicIp", name, args ?? new PublicIpArgs(), MakeResourceOptions(options, "")) + { + } + + private PublicIp(string name, Input id, PublicIpState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/publicIp:PublicIp", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 PublicIp 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 PublicIp Get(string name, Input id, PublicIpState? state = null, CustomResourceOptions? options = null) + { + return new PublicIp(name, id, state, options); + } + } + + public sealed class PublicIpArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + [Input("networkInterfaceId")] + public Input? NetworkInterfaceId { get; set; } + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public PublicIpArgs() + { + } + public static new PublicIpArgs Empty => new PublicIpArgs(); + } + + public sealed class PublicIpState : global::Pulumi.ResourceArgs + { + /// + /// The IP address. + /// + [Input("ip")] + public Input? Ip { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + [Input("networkInterfaceId")] + public Input? NetworkInterfaceId { get; set; } + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The public IP ID. + /// + [Input("publicIpId")] + public Input? PublicIpId { get; set; } + + public PublicIpState() + { + } + public static new PublicIpState Empty => new PublicIpState(); + } +} diff --git a/sdk/dotnet/PublicIpAssociate.cs b/sdk/dotnet/PublicIpAssociate.cs new file mode 100644 index 0000000..9b220ea --- /dev/null +++ b/sdk/dotnet/PublicIpAssociate.cs @@ -0,0 +1,149 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `stackit.PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration. + /// + /// !> The `stackit.PublicIpAssociate` resource should not be used together with the `stackit.PublicIp` resource for the same public IP or for the same network interface. + /// Using both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/publicIpAssociate:PublicIpAssociate")] + public partial class PublicIpAssociate : global::Pulumi.CustomResource + { + /// + /// The IP address. + /// + [Output("ip")] + public Output Ip { get; private set; } = null!; + + /// + /// The ID of the network interface (or virtual IP) to which the public IP should be attached to. + /// + [Output("networkInterfaceId")] + public Output NetworkInterfaceId { get; private set; } = null!; + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The public IP ID. + /// + [Output("publicIpId")] + public Output PublicIpId { get; private set; } = null!; + + + /// + /// Create a PublicIpAssociate 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 PublicIpAssociate(string name, PublicIpAssociateArgs args, CustomResourceOptions? options = null) + : base("stackit:index/publicIpAssociate:PublicIpAssociate", name, args ?? new PublicIpAssociateArgs(), MakeResourceOptions(options, "")) + { + } + + private PublicIpAssociate(string name, Input id, PublicIpAssociateState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/publicIpAssociate:PublicIpAssociate", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 PublicIpAssociate 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 PublicIpAssociate Get(string name, Input id, PublicIpAssociateState? state = null, CustomResourceOptions? options = null) + { + return new PublicIpAssociate(name, id, state, options); + } + } + + public sealed class PublicIpAssociateArgs : global::Pulumi.ResourceArgs + { + /// + /// The ID of the network interface (or virtual IP) to which the public IP should be attached to. + /// + [Input("networkInterfaceId", required: true)] + public Input NetworkInterfaceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The public IP ID. + /// + [Input("publicIpId", required: true)] + public Input PublicIpId { get; set; } = null!; + + public PublicIpAssociateArgs() + { + } + public static new PublicIpAssociateArgs Empty => new PublicIpAssociateArgs(); + } + + public sealed class PublicIpAssociateState : global::Pulumi.ResourceArgs + { + /// + /// The IP address. + /// + [Input("ip")] + public Input? Ip { get; set; } + + /// + /// The ID of the network interface (or virtual IP) to which the public IP should be attached to. + /// + [Input("networkInterfaceId")] + public Input? NetworkInterfaceId { get; set; } + + /// + /// STACKIT project ID to which the public IP is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The public IP ID. + /// + [Input("publicIpId")] + public Input? PublicIpId { get; set; } + + public PublicIpAssociateState() + { + } + public static new PublicIpAssociateState Empty => new PublicIpAssociateState(); + } +} diff --git a/sdk/dotnet/Pulumi.Stackit.csproj b/sdk/dotnet/Pulumi.Stackit.csproj new file mode 100644 index 0000000..c081bcc --- /dev/null +++ b/sdk/dotnet/Pulumi.Stackit.csproj @@ -0,0 +1,60 @@ + + + + true + stackitcloud + stackitcloud + A Pulumi package for creating and managing stackit resources. + Apache-2.0 + https://www.pulumi.com + https://github.com/stackitcloud/pulumi-stackit + logo.png + + net6.0 + enable + + + + true + 1701;1702;1591 + + + + $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb + true + true + + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + True + + + + + diff --git a/sdk/dotnet/Pulumi.yaml b/sdk/dotnet/Pulumi.yaml new file mode 100644 index 0000000..e69de29 diff --git a/sdk/dotnet/README.md b/sdk/dotnet/README.md new file mode 100644 index 0000000..cb19b45 --- /dev/null +++ b/sdk/dotnet/README.md @@ -0,0 +1 @@ +A Pulumi package for creating and managing stackit resources. diff --git a/sdk/dotnet/RabbitmqCredential.cs b/sdk/dotnet/RabbitmqCredential.cs new file mode 100644 index 0000000..0c8c2bf --- /dev/null +++ b/sdk/dotnet/RabbitmqCredential.cs @@ -0,0 +1,226 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/rabbitmqCredential:RabbitmqCredential")] + public partial class RabbitmqCredential : global::Pulumi.CustomResource + { + /// + /// The credential's ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + [Output("hosts")] + public Output> Hosts { get; private set; } = null!; + + [Output("httpApiUri")] + public Output HttpApiUri { get; private set; } = null!; + + [Output("httpApiUris")] + public Output> HttpApiUris { get; private set; } = null!; + + /// + /// ID of the RabbitMQ instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("management")] + public Output Management { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("uri")] + public Output Uri { get; private set; } = null!; + + [Output("uris")] + public Output> Uris { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a RabbitmqCredential 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 RabbitmqCredential(string name, RabbitmqCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/rabbitmqCredential:RabbitmqCredential", name, args ?? new RabbitmqCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private RabbitmqCredential(string name, Input id, RabbitmqCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/rabbitmqCredential:RabbitmqCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 RabbitmqCredential 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 RabbitmqCredential Get(string name, Input id, RabbitmqCredentialState? state = null, CustomResourceOptions? options = null) + { + return new RabbitmqCredential(name, id, state, options); + } + } + + public sealed class RabbitmqCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public RabbitmqCredentialArgs() + { + } + public static new RabbitmqCredentialArgs Empty => new RabbitmqCredentialArgs(); + } + + public sealed class RabbitmqCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + [Input("hosts")] + private InputList? _hosts; + public InputList Hosts + { + get => _hosts ?? (_hosts = new InputList()); + set => _hosts = value; + } + + [Input("httpApiUri")] + public Input? HttpApiUri { get; set; } + + [Input("httpApiUris")] + private InputList? _httpApiUris; + public InputList HttpApiUris + { + get => _httpApiUris ?? (_httpApiUris = new InputList()); + set => _httpApiUris = value; + } + + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("management")] + public Input? Management { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("uri")] + private Input? _uri; + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("uris")] + private InputList? _uris; + public InputList Uris + { + get => _uris ?? (_uris = new InputList()); + set => _uris = value; + } + + [Input("username")] + public Input? Username { get; set; } + + public RabbitmqCredentialState() + { + } + public static new RabbitmqCredentialState Empty => new RabbitmqCredentialState(); + } +} diff --git a/sdk/dotnet/RabbitmqInstance.cs b/sdk/dotnet/RabbitmqInstance.cs new file mode 100644 index 0000000..bb1b4b2 --- /dev/null +++ b/sdk/dotnet/RabbitmqInstance.cs @@ -0,0 +1,215 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/rabbitmqInstance:RabbitmqInstance")] + public partial class RabbitmqInstance : global::Pulumi.CustomResource + { + [Output("cfGuid")] + public Output CfGuid { get; private set; } = null!; + + [Output("cfOrganizationGuid")] + public Output CfOrganizationGuid { get; private set; } = null!; + + [Output("cfSpaceGuid")] + public Output CfSpaceGuid { get; private set; } = null!; + + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + [Output("imageUrl")] + public Output ImageUrl { get; private set; } = null!; + + /// + /// ID of the RabbitMQ instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("parameters")] + public Output Parameters { get; private set; } = null!; + + /// + /// The selected plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// The selected plan name. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The service version. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a RabbitmqInstance 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 RabbitmqInstance(string name, RabbitmqInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/rabbitmqInstance:RabbitmqInstance", name, args ?? new RabbitmqInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private RabbitmqInstance(string name, Input id, RabbitmqInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/rabbitmqInstance:RabbitmqInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 RabbitmqInstance 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 RabbitmqInstance Get(string name, Input id, RabbitmqInstanceState? state = null, CustomResourceOptions? options = null) + { + return new RabbitmqInstance(name, id, state, options); + } + } + + public sealed class RabbitmqInstanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The service version. + /// + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public RabbitmqInstanceArgs() + { + } + public static new RabbitmqInstanceArgs Empty => new RabbitmqInstanceArgs(); + } + + public sealed class RabbitmqInstanceState : global::Pulumi.ResourceArgs + { + [Input("cfGuid")] + public Input? CfGuid { get; set; } + + [Input("cfOrganizationGuid")] + public Input? CfOrganizationGuid { get; set; } + + [Input("cfSpaceGuid")] + public Input? CfSpaceGuid { get; set; } + + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("imageUrl")] + public Input? ImageUrl { get; set; } + + /// + /// ID of the RabbitMQ instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The service version. + /// + [Input("version")] + public Input? Version { get; set; } + + public RabbitmqInstanceState() + { + } + public static new RabbitmqInstanceState Empty => new RabbitmqInstanceState(); + } +} diff --git a/sdk/dotnet/RedisCredential.cs b/sdk/dotnet/RedisCredential.cs new file mode 100644 index 0000000..41e9498 --- /dev/null +++ b/sdk/dotnet/RedisCredential.cs @@ -0,0 +1,205 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Redis credential resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/redisCredential:RedisCredential")] + public partial class RedisCredential : global::Pulumi.CustomResource + { + /// + /// The credential's ID. + /// + [Output("credentialId")] + public Output CredentialId { get; private set; } = null!; + + [Output("host")] + public Output Host { get; private set; } = null!; + + [Output("hosts")] + public Output> Hosts { get; private set; } = null!; + + /// + /// ID of the Redis instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + [Output("loadBalancedHost")] + public Output LoadBalancedHost { get; private set; } = null!; + + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Connection URI. + /// + [Output("uri")] + public Output Uri { get; private set; } = null!; + + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a RedisCredential 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 RedisCredential(string name, RedisCredentialArgs args, CustomResourceOptions? options = null) + : base("stackit:index/redisCredential:RedisCredential", name, args ?? new RedisCredentialArgs(), MakeResourceOptions(options, "")) + { + } + + private RedisCredential(string name, Input id, RedisCredentialState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/redisCredential:RedisCredential", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + "uri", + }, + }; + 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 RedisCredential 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 RedisCredential Get(string name, Input id, RedisCredentialState? state = null, CustomResourceOptions? options = null) + { + return new RedisCredential(name, id, state, options); + } + } + + public sealed class RedisCredentialArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the Redis instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public RedisCredentialArgs() + { + } + public static new RedisCredentialArgs Empty => new RedisCredentialArgs(); + } + + public sealed class RedisCredentialState : global::Pulumi.ResourceArgs + { + /// + /// The credential's ID. + /// + [Input("credentialId")] + public Input? CredentialId { get; set; } + + [Input("host")] + public Input? Host { get; set; } + + [Input("hosts")] + private InputList? _hosts; + public InputList Hosts + { + get => _hosts ?? (_hosts = new InputList()); + set => _hosts = value; + } + + /// + /// ID of the Redis instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("loadBalancedHost")] + public Input? LoadBalancedHost { get; set; } + + [Input("password")] + private Input? _password; + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("uri")] + private Input? _uri; + + /// + /// Connection URI. + /// + public Input? Uri + { + get => _uri; + set + { + var emptySecret = Output.CreateSecret(0); + _uri = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("username")] + public Input? Username { get; set; } + + public RedisCredentialState() + { + } + public static new RedisCredentialState Empty => new RedisCredentialState(); + } +} diff --git a/sdk/dotnet/RedisInstance.cs b/sdk/dotnet/RedisInstance.cs new file mode 100644 index 0000000..232f9db --- /dev/null +++ b/sdk/dotnet/RedisInstance.cs @@ -0,0 +1,215 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Redis instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/redisInstance:RedisInstance")] + public partial class RedisInstance : global::Pulumi.CustomResource + { + [Output("cfGuid")] + public Output CfGuid { get; private set; } = null!; + + [Output("cfOrganizationGuid")] + public Output CfOrganizationGuid { get; private set; } = null!; + + [Output("cfSpaceGuid")] + public Output CfSpaceGuid { get; private set; } = null!; + + [Output("dashboardUrl")] + public Output DashboardUrl { get; private set; } = null!; + + [Output("imageUrl")] + public Output ImageUrl { get; private set; } = null!; + + /// + /// ID of the Redis instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("parameters")] + public Output Parameters { get; private set; } = null!; + + /// + /// The selected plan ID. + /// + [Output("planId")] + public Output PlanId { get; private set; } = null!; + + /// + /// The selected plan name. + /// + [Output("planName")] + public Output PlanName { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The service version. + /// + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a RedisInstance 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 RedisInstance(string name, RedisInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/redisInstance:RedisInstance", name, args ?? new RedisInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private RedisInstance(string name, Input id, RedisInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/redisInstance:RedisInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 RedisInstance 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 RedisInstance Get(string name, Input id, RedisInstanceState? state = null, CustomResourceOptions? options = null) + { + return new RedisInstance(name, id, state, options); + } + } + + public sealed class RedisInstanceArgs : global::Pulumi.ResourceArgs + { + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName", required: true)] + public Input PlanName { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The service version. + /// + [Input("version", required: true)] + public Input Version { get; set; } = null!; + + public RedisInstanceArgs() + { + } + public static new RedisInstanceArgs Empty => new RedisInstanceArgs(); + } + + public sealed class RedisInstanceState : global::Pulumi.ResourceArgs + { + [Input("cfGuid")] + public Input? CfGuid { get; set; } + + [Input("cfOrganizationGuid")] + public Input? CfOrganizationGuid { get; set; } + + [Input("cfSpaceGuid")] + public Input? CfSpaceGuid { get; set; } + + [Input("dashboardUrl")] + public Input? DashboardUrl { get; set; } + + [Input("imageUrl")] + public Input? ImageUrl { get; set; } + + /// + /// ID of the Redis instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("parameters")] + public Input? Parameters { get; set; } + + /// + /// The selected plan ID. + /// + [Input("planId")] + public Input? PlanId { get; set; } + + /// + /// The selected plan name. + /// + [Input("planName")] + public Input? PlanName { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The service version. + /// + [Input("version")] + public Input? Version { get; set; } + + public RedisInstanceState() + { + } + public static new RedisInstanceState Empty => new RedisInstanceState(); + } +} diff --git a/sdk/dotnet/ResourcemanagerProject.cs b/sdk/dotnet/ResourcemanagerProject.cs new file mode 100644 index 0000000..ac47117 --- /dev/null +++ b/sdk/dotnet/ResourcemanagerProject.cs @@ -0,0 +1,186 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/resourcemanagerProject:ResourcemanagerProject")] + public partial class ResourcemanagerProject : global::Pulumi.CustomResource + { + /// + /// Project container ID. Globally unique, user-friendly identifier. + /// + [Output("containerId")] + public Output ContainerId { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=<networkAreaID>` is required. + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// Project name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + /// + [Output("ownerEmail")] + public Output OwnerEmail { get; private set; } = null!; + + /// + /// Parent resource identifier. Both container ID (user-friendly) and UUID are supported + /// + [Output("parentContainerId")] + public Output ParentContainerId { get; private set; } = null!; + + /// + /// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + + /// + /// Create a ResourcemanagerProject 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 ResourcemanagerProject(string name, ResourcemanagerProjectArgs args, CustomResourceOptions? options = null) + : base("stackit:index/resourcemanagerProject:ResourcemanagerProject", name, args ?? new ResourcemanagerProjectArgs(), MakeResourceOptions(options, "")) + { + } + + private ResourcemanagerProject(string name, Input id, ResourcemanagerProjectState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/resourcemanagerProject:ResourcemanagerProject", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ResourcemanagerProject 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 ResourcemanagerProject Get(string name, Input id, ResourcemanagerProjectState? state = null, CustomResourceOptions? options = null) + { + return new ResourcemanagerProject(name, id, state, options); + } + } + + public sealed class ResourcemanagerProjectArgs : global::Pulumi.ResourceArgs + { + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=<networkAreaID>` is required. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// Project name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + /// + [Input("ownerEmail", required: true)] + public Input OwnerEmail { get; set; } = null!; + + /// + /// Parent resource identifier. Both container ID (user-friendly) and UUID are supported + /// + [Input("parentContainerId", required: true)] + public Input ParentContainerId { get; set; } = null!; + + public ResourcemanagerProjectArgs() + { + } + public static new ResourcemanagerProjectArgs Empty => new ResourcemanagerProjectArgs(); + } + + public sealed class ResourcemanagerProjectState : global::Pulumi.ResourceArgs + { + /// + /// Project container ID. Globally unique, user-friendly identifier. + /// + [Input("containerId")] + public Input? ContainerId { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=<networkAreaID>` is required. + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// Project name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + /// + [Input("ownerEmail")] + public Input? OwnerEmail { get; set; } + + /// + /// Parent resource identifier. Both container ID (user-friendly) and UUID are supported + /// + [Input("parentContainerId")] + public Input? ParentContainerId { get; set; } + + /// + /// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + public ResourcemanagerProjectState() + { + } + public static new ResourcemanagerProjectState Empty => new ResourcemanagerProjectState(); + } +} diff --git a/sdk/dotnet/SecretsmanagerInstance.cs b/sdk/dotnet/SecretsmanagerInstance.cs new file mode 100644 index 0000000..2185690 --- /dev/null +++ b/sdk/dotnet/SecretsmanagerInstance.cs @@ -0,0 +1,158 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/secretsmanagerInstance:SecretsmanagerInstance")] + public partial class SecretsmanagerInstance : global::Pulumi.CustomResource + { + /// + /// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + /// + [Output("acls")] + public Output> Acls { get; private set; } = null!; + + /// + /// ID of the Secrets Manager instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + + /// + /// Create a SecretsmanagerInstance 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 SecretsmanagerInstance(string name, SecretsmanagerInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/secretsmanagerInstance:SecretsmanagerInstance", name, args ?? new SecretsmanagerInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private SecretsmanagerInstance(string name, Input id, SecretsmanagerInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/secretsmanagerInstance:SecretsmanagerInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 SecretsmanagerInstance 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 SecretsmanagerInstance Get(string name, Input id, SecretsmanagerInstanceState? state = null, CustomResourceOptions? options = null) + { + return new SecretsmanagerInstance(name, id, state, options); + } + } + + public sealed class SecretsmanagerInstanceArgs : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public SecretsmanagerInstanceArgs() + { + } + public static new SecretsmanagerInstanceArgs Empty => new SecretsmanagerInstanceArgs(); + } + + public sealed class SecretsmanagerInstanceState : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + public SecretsmanagerInstanceState() + { + } + public static new SecretsmanagerInstanceState Empty => new SecretsmanagerInstanceState(); + } +} diff --git a/sdk/dotnet/SecretsmanagerUser.cs b/sdk/dotnet/SecretsmanagerUser.cs new file mode 100644 index 0000000..8eaf809 --- /dev/null +++ b/sdk/dotnet/SecretsmanagerUser.cs @@ -0,0 +1,202 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Secrets Manager user resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/secretsmanagerUser:SecretsmanagerUser")] + public partial class SecretsmanagerUser : global::Pulumi.CustomResource + { + /// + /// A user chosen description to differentiate between multiple users. Can't be changed after creation. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// ID of the Secrets Manager instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// An auto-generated password. + /// + [Output("password")] + public Output Password { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The user's ID. + /// + [Output("userId")] + public Output UserId { get; private set; } = null!; + + /// + /// An auto-generated user name. + /// + [Output("username")] + public Output Username { get; private set; } = null!; + + /// + /// If true, the user has writeaccess to the secrets engine. + /// + [Output("writeEnabled")] + public Output WriteEnabled { get; private set; } = null!; + + + /// + /// Create a SecretsmanagerUser 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 SecretsmanagerUser(string name, SecretsmanagerUserArgs args, CustomResourceOptions? options = null) + : base("stackit:index/secretsmanagerUser:SecretsmanagerUser", name, args ?? new SecretsmanagerUserArgs(), MakeResourceOptions(options, "")) + { + } + + private SecretsmanagerUser(string name, Input id, SecretsmanagerUserState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/secretsmanagerUser:SecretsmanagerUser", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + }, + }; + 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 SecretsmanagerUser 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 SecretsmanagerUser Get(string name, Input id, SecretsmanagerUserState? state = null, CustomResourceOptions? options = null) + { + return new SecretsmanagerUser(name, id, state, options); + } + } + + public sealed class SecretsmanagerUserArgs : global::Pulumi.ResourceArgs + { + /// + /// A user chosen description to differentiate between multiple users. Can't be changed after creation. + /// + [Input("description", required: true)] + public Input Description { get; set; } = null!; + + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// If true, the user has writeaccess to the secrets engine. + /// + [Input("writeEnabled", required: true)] + public Input WriteEnabled { get; set; } = null!; + + public SecretsmanagerUserArgs() + { + } + public static new SecretsmanagerUserArgs Empty => new SecretsmanagerUserArgs(); + } + + public sealed class SecretsmanagerUserState : global::Pulumi.ResourceArgs + { + /// + /// A user chosen description to differentiate between multiple users. Can't be changed after creation. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// ID of the Secrets Manager instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + + /// + /// An auto-generated password. + /// + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// STACKIT Project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The user's ID. + /// + [Input("userId")] + public Input? UserId { get; set; } + + /// + /// An auto-generated user name. + /// + [Input("username")] + public Input? Username { get; set; } + + /// + /// If true, the user has writeaccess to the secrets engine. + /// + [Input("writeEnabled")] + public Input? WriteEnabled { get; set; } + + public SecretsmanagerUserState() + { + } + public static new SecretsmanagerUserState Empty => new SecretsmanagerUserState(); + } +} diff --git a/sdk/dotnet/SecurityGroup.cs b/sdk/dotnet/SecurityGroup.cs new file mode 100644 index 0000000..81aac47 --- /dev/null +++ b/sdk/dotnet/SecurityGroup.cs @@ -0,0 +1,194 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Security group resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/securityGroup:SecurityGroup")] + public partial class SecurityGroup : global::Pulumi.CustomResource + { + /// + /// The description of the security group. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The name of the security group. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the security group is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The security group ID. + /// + [Output("securityGroupId")] + public Output SecurityGroupId { get; private set; } = null!; + + /// + /// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + /// + [Output("stateful")] + public Output Stateful { get; private set; } = null!; + + + /// + /// Create a SecurityGroup 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 SecurityGroup(string name, SecurityGroupArgs args, CustomResourceOptions? options = null) + : base("stackit:index/securityGroup:SecurityGroup", name, args ?? new SecurityGroupArgs(), MakeResourceOptions(options, "")) + { + } + + private SecurityGroup(string name, Input id, SecurityGroupState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/securityGroup:SecurityGroup", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 SecurityGroup 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 SecurityGroup Get(string name, Input id, SecurityGroupState? state = null, CustomResourceOptions? options = null) + { + return new SecurityGroup(name, id, state, options); + } + } + + public sealed class SecurityGroupArgs : global::Pulumi.ResourceArgs + { + /// + /// The description of the security group. + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the security group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the security group is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + /// + [Input("stateful")] + public Input? Stateful { get; set; } + + public SecurityGroupArgs() + { + } + public static new SecurityGroupArgs Empty => new SecurityGroupArgs(); + } + + public sealed class SecurityGroupState : global::Pulumi.ResourceArgs + { + /// + /// The description of the security group. + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the security group. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the security group is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The security group ID. + /// + [Input("securityGroupId")] + public Input? SecurityGroupId { get; set; } + + /// + /// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + /// + [Input("stateful")] + public Input? Stateful { get; set; } + + public SecurityGroupState() + { + } + public static new SecurityGroupState Empty => new SecurityGroupState(); + } +} diff --git a/sdk/dotnet/SecurityGroupRule.cs b/sdk/dotnet/SecurityGroupRule.cs new file mode 100644 index 0000000..0c92e24 --- /dev/null +++ b/sdk/dotnet/SecurityGroupRule.cs @@ -0,0 +1,272 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Security group rule resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/securityGroupRule:SecurityGroupRule")] + public partial class SecurityGroupRule : global::Pulumi.CustomResource + { + /// + /// The rule description. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + /// + [Output("direction")] + public Output Direction { get; private set; } = null!; + + /// + /// The ethertype which the rule should match. + /// + [Output("etherType")] + public Output EtherType { get; private set; } = null!; + + /// + /// ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + /// + [Output("icmpParameters")] + public Output IcmpParameters { get; private set; } = null!; + + /// + /// The remote IP range which the rule should match. + /// + [Output("ipRange")] + public Output IpRange { get; private set; } = null!; + + /// + /// The range of ports. This should only be provided if the protocol is not ICMP. + /// + [Output("portRange")] + public Output PortRange { get; private set; } = null!; + + /// + /// STACKIT project ID to which the security group rule is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The internet protocol which the rule should match. + /// + [Output("protocol")] + public Output Protocol { get; private set; } = null!; + + /// + /// The remote security group which the rule should match. + /// + [Output("remoteSecurityGroupId")] + public Output RemoteSecurityGroupId { get; private set; } = null!; + + /// + /// The security group ID. + /// + [Output("securityGroupId")] + public Output SecurityGroupId { get; private set; } = null!; + + /// + /// The security group rule ID. + /// + [Output("securityGroupRuleId")] + public Output SecurityGroupRuleId { get; private set; } = null!; + + + /// + /// Create a SecurityGroupRule 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 SecurityGroupRule(string name, SecurityGroupRuleArgs args, CustomResourceOptions? options = null) + : base("stackit:index/securityGroupRule:SecurityGroupRule", name, args ?? new SecurityGroupRuleArgs(), MakeResourceOptions(options, "")) + { + } + + private SecurityGroupRule(string name, Input id, SecurityGroupRuleState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/securityGroupRule:SecurityGroupRule", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 SecurityGroupRule 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 SecurityGroupRule Get(string name, Input id, SecurityGroupRuleState? state = null, CustomResourceOptions? options = null) + { + return new SecurityGroupRule(name, id, state, options); + } + } + + public sealed class SecurityGroupRuleArgs : global::Pulumi.ResourceArgs + { + /// + /// The rule description. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + /// + [Input("direction", required: true)] + public Input Direction { get; set; } = null!; + + /// + /// The ethertype which the rule should match. + /// + [Input("etherType")] + public Input? EtherType { get; set; } + + /// + /// ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + /// + [Input("icmpParameters")] + public Input? IcmpParameters { get; set; } + + /// + /// The remote IP range which the rule should match. + /// + [Input("ipRange")] + public Input? IpRange { get; set; } + + /// + /// The range of ports. This should only be provided if the protocol is not ICMP. + /// + [Input("portRange")] + public Input? PortRange { get; set; } + + /// + /// STACKIT project ID to which the security group rule is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The internet protocol which the rule should match. + /// + [Input("protocol")] + public Input? Protocol { get; set; } + + /// + /// The remote security group which the rule should match. + /// + [Input("remoteSecurityGroupId")] + public Input? RemoteSecurityGroupId { get; set; } + + /// + /// The security group ID. + /// + [Input("securityGroupId", required: true)] + public Input SecurityGroupId { get; set; } = null!; + + public SecurityGroupRuleArgs() + { + } + public static new SecurityGroupRuleArgs Empty => new SecurityGroupRuleArgs(); + } + + public sealed class SecurityGroupRuleState : global::Pulumi.ResourceArgs + { + /// + /// The rule description. + /// + [Input("description")] + public Input? Description { get; set; } + + /// + /// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + /// + [Input("direction")] + public Input? Direction { get; set; } + + /// + /// The ethertype which the rule should match. + /// + [Input("etherType")] + public Input? EtherType { get; set; } + + /// + /// ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + /// + [Input("icmpParameters")] + public Input? IcmpParameters { get; set; } + + /// + /// The remote IP range which the rule should match. + /// + [Input("ipRange")] + public Input? IpRange { get; set; } + + /// + /// The range of ports. This should only be provided if the protocol is not ICMP. + /// + [Input("portRange")] + public Input? PortRange { get; set; } + + /// + /// STACKIT project ID to which the security group rule is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The internet protocol which the rule should match. + /// + [Input("protocol")] + public Input? Protocol { get; set; } + + /// + /// The remote security group which the rule should match. + /// + [Input("remoteSecurityGroupId")] + public Input? RemoteSecurityGroupId { get; set; } + + /// + /// The security group ID. + /// + [Input("securityGroupId")] + public Input? SecurityGroupId { get; set; } + + /// + /// The security group rule ID. + /// + [Input("securityGroupRuleId")] + public Input? SecurityGroupRuleId { get; set; } + + public SecurityGroupRuleState() + { + } + public static new SecurityGroupRuleState Empty => new SecurityGroupRuleState(); + } +} diff --git a/sdk/dotnet/Server.cs b/sdk/dotnet/Server.cs new file mode 100644 index 0000000..240fd92 --- /dev/null +++ b/sdk/dotnet/Server.cs @@ -0,0 +1,380 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Server resource schema. Must have a region specified in the provider configuration. + /// + /// ## Example Usage + /// + /// ### With key pair + /// + /// ### Boot from volume + /// + /// ### Boot from existing volume + /// + /// ### Network setup + /// + /// ### Server with attached volume + /// + /// ### Server with user data (cloud-init) + /// + [StackitResourceType("stackit:index/server:Server")] + public partial class Server : global::Pulumi.CustomResource + { + /// + /// The affinity group the server is assigned to. + /// + [Output("affinityGroup")] + public Output AffinityGroup { get; private set; } = null!; + + /// + /// The availability zone of the server. + /// + [Output("availabilityZone")] + public Output AvailabilityZone { get; private set; } = null!; + + /// + /// The boot volume for the server + /// + [Output("bootVolume")] + public Output BootVolume { get; private set; } = null!; + + /// + /// Date-time when the server was created + /// + [Output("createdAt")] + public Output CreatedAt { get; private set; } = null!; + + /// + /// The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + /// + [Output("desiredStatus")] + public Output DesiredStatus { get; private set; } = null!; + + /// + /// The image ID to be used for an ephemeral disk on the server. + /// + [Output("imageId")] + public Output ImageId { get; private set; } = null!; + + /// + /// The name of the keypair used during server creation. + /// + [Output("keypairName")] + public Output KeypairName { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// Date-time when the server was launched + /// + [Output("launchedAt")] + public Output LaunchedAt { get; private set; } = null!; + + /// + /// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + /// + [Output("machineType")] + public Output MachineType { get; private set; } = null!; + + /// + /// The name of the server. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + /// + [Output("networkInterfaces")] + public Output> NetworkInterfaces { get; private set; } = null!; + + /// + /// STACKIT project ID to which the server is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The server ID. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + /// + /// Date-time when the server was updated + /// + [Output("updatedAt")] + public Output UpdatedAt { get; private set; } = null!; + + /// + /// User data that is passed via cloud-init to the server. + /// + [Output("userData")] + public Output UserData { get; private set; } = null!; + + + /// + /// Create a Server 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 Server(string name, ServerArgs args, CustomResourceOptions? options = null) + : base("stackit:index/server:Server", name, args ?? new ServerArgs(), MakeResourceOptions(options, "")) + { + } + + private Server(string name, Input id, ServerState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/server:Server", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Server 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 Server Get(string name, Input id, ServerState? state = null, CustomResourceOptions? options = null) + { + return new Server(name, id, state, options); + } + } + + public sealed class ServerArgs : global::Pulumi.ResourceArgs + { + /// + /// The affinity group the server is assigned to. + /// + [Input("affinityGroup")] + public Input? AffinityGroup { get; set; } + + /// + /// The availability zone of the server. + /// + [Input("availabilityZone")] + public Input? AvailabilityZone { get; set; } + + /// + /// The boot volume for the server + /// + [Input("bootVolume")] + public Input? BootVolume { get; set; } + + /// + /// The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + /// + [Input("desiredStatus")] + public Input? DesiredStatus { get; set; } + + /// + /// The image ID to be used for an ephemeral disk on the server. + /// + [Input("imageId")] + public Input? ImageId { get; set; } + + /// + /// The name of the keypair used during server creation. + /// + [Input("keypairName")] + public Input? KeypairName { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + /// + [Input("machineType", required: true)] + public Input MachineType { get; set; } = null!; + + /// + /// The name of the server. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("networkInterfaces")] + private InputList? _networkInterfaces; + + /// + /// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + /// + public InputList NetworkInterfaces + { + get => _networkInterfaces ?? (_networkInterfaces = new InputList()); + set => _networkInterfaces = value; + } + + /// + /// STACKIT project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// User data that is passed via cloud-init to the server. + /// + [Input("userData")] + public Input? UserData { get; set; } + + public ServerArgs() + { + } + public static new ServerArgs Empty => new ServerArgs(); + } + + public sealed class ServerState : global::Pulumi.ResourceArgs + { + /// + /// The affinity group the server is assigned to. + /// + [Input("affinityGroup")] + public Input? AffinityGroup { get; set; } + + /// + /// The availability zone of the server. + /// + [Input("availabilityZone")] + public Input? AvailabilityZone { get; set; } + + /// + /// The boot volume for the server + /// + [Input("bootVolume")] + public Input? BootVolume { get; set; } + + /// + /// Date-time when the server was created + /// + [Input("createdAt")] + public Input? CreatedAt { get; set; } + + /// + /// The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + /// + [Input("desiredStatus")] + public Input? DesiredStatus { get; set; } + + /// + /// The image ID to be used for an ephemeral disk on the server. + /// + [Input("imageId")] + public Input? ImageId { get; set; } + + /// + /// The name of the keypair used during server creation. + /// + [Input("keypairName")] + public Input? KeypairName { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// Date-time when the server was launched + /// + [Input("launchedAt")] + public Input? LaunchedAt { get; set; } + + /// + /// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + /// + [Input("machineType")] + public Input? MachineType { get; set; } + + /// + /// The name of the server. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("networkInterfaces")] + private InputList? _networkInterfaces; + + /// + /// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + /// + public InputList NetworkInterfaces + { + get => _networkInterfaces ?? (_networkInterfaces = new InputList()); + set => _networkInterfaces = value; + } + + /// + /// STACKIT project ID to which the server is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The server ID. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + /// + /// Date-time when the server was updated + /// + [Input("updatedAt")] + public Input? UpdatedAt { get; set; } + + /// + /// User data that is passed via cloud-init to the server. + /// + [Input("userData")] + public Input? UserData { get; set; } + + public ServerState() + { + } + public static new ServerState Empty => new ServerState(); + } +} diff --git a/sdk/dotnet/ServerBackupSchedule.cs b/sdk/dotnet/ServerBackupSchedule.cs new file mode 100644 index 0000000..5df195f --- /dev/null +++ b/sdk/dotnet/ServerBackupSchedule.cs @@ -0,0 +1,220 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Server backup schedule resource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serverBackupSchedule:ServerBackupSchedule")] + public partial class ServerBackupSchedule : global::Pulumi.CustomResource + { + /// + /// Backup schedule details for the backups. + /// + [Output("backupProperties")] + public Output BackupProperties { get; private set; } = null!; + + /// + /// Backup schedule ID. + /// + [Output("backupScheduleId")] + public Output BackupScheduleId { get; private set; } = null!; + + /// + /// Is the backup schedule enabled or disabled. + /// + [Output("enabled")] + public Output Enabled { get; private set; } = null!; + + /// + /// The schedule name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Backup schedule described in `rrule` (recurrence rule) format. + /// + [Output("rrule")] + public Output Rrule { get; private set; } = null!; + + /// + /// Server ID for the backup schedule. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + + /// + /// Create a ServerBackupSchedule 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 ServerBackupSchedule(string name, ServerBackupScheduleArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serverBackupSchedule:ServerBackupSchedule", name, args ?? new ServerBackupScheduleArgs(), MakeResourceOptions(options, "")) + { + } + + private ServerBackupSchedule(string name, Input id, ServerBackupScheduleState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serverBackupSchedule:ServerBackupSchedule", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServerBackupSchedule 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 ServerBackupSchedule Get(string name, Input id, ServerBackupScheduleState? state = null, CustomResourceOptions? options = null) + { + return new ServerBackupSchedule(name, id, state, options); + } + } + + public sealed class ServerBackupScheduleArgs : global::Pulumi.ResourceArgs + { + /// + /// Backup schedule details for the backups. + /// + [Input("backupProperties", required: true)] + public Input BackupProperties { get; set; } = null!; + + /// + /// Is the backup schedule enabled or disabled. + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + /// + /// The schedule name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Backup schedule described in `rrule` (recurrence rule) format. + /// + [Input("rrule", required: true)] + public Input Rrule { get; set; } = null!; + + /// + /// Server ID for the backup schedule. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public ServerBackupScheduleArgs() + { + } + public static new ServerBackupScheduleArgs Empty => new ServerBackupScheduleArgs(); + } + + public sealed class ServerBackupScheduleState : global::Pulumi.ResourceArgs + { + /// + /// Backup schedule details for the backups. + /// + [Input("backupProperties")] + public Input? BackupProperties { get; set; } + + /// + /// Backup schedule ID. + /// + [Input("backupScheduleId")] + public Input? BackupScheduleId { get; set; } + + /// + /// Is the backup schedule enabled or disabled. + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// The schedule name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Backup schedule described in `rrule` (recurrence rule) format. + /// + [Input("rrule")] + public Input? Rrule { get; set; } + + /// + /// Server ID for the backup schedule. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + public ServerBackupScheduleState() + { + } + public static new ServerBackupScheduleState Empty => new ServerBackupScheduleState(); + } +} diff --git a/sdk/dotnet/ServerNetworkInterfaceAttach.cs b/sdk/dotnet/ServerNetworkInterfaceAttach.cs new file mode 100644 index 0000000..25afd13 --- /dev/null +++ b/sdk/dotnet/ServerNetworkInterfaceAttach.cs @@ -0,0 +1,134 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach")] + public partial class ServerNetworkInterfaceAttach : global::Pulumi.CustomResource + { + /// + /// The network interface ID. + /// + [Output("networkInterfaceId")] + public Output NetworkInterfaceId { get; private set; } = null!; + + /// + /// STACKIT project ID to which the network interface attachment is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The server ID. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + + /// + /// Create a ServerNetworkInterfaceAttach 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 ServerNetworkInterfaceAttach(string name, ServerNetworkInterfaceAttachArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach", name, args ?? new ServerNetworkInterfaceAttachArgs(), MakeResourceOptions(options, "")) + { + } + + private ServerNetworkInterfaceAttach(string name, Input id, ServerNetworkInterfaceAttachState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServerNetworkInterfaceAttach 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 ServerNetworkInterfaceAttach Get(string name, Input id, ServerNetworkInterfaceAttachState? state = null, CustomResourceOptions? options = null) + { + return new ServerNetworkInterfaceAttach(name, id, state, options); + } + } + + public sealed class ServerNetworkInterfaceAttachArgs : global::Pulumi.ResourceArgs + { + /// + /// The network interface ID. + /// + [Input("networkInterfaceId", required: true)] + public Input NetworkInterfaceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the network interface attachment is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The server ID. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public ServerNetworkInterfaceAttachArgs() + { + } + public static new ServerNetworkInterfaceAttachArgs Empty => new ServerNetworkInterfaceAttachArgs(); + } + + public sealed class ServerNetworkInterfaceAttachState : global::Pulumi.ResourceArgs + { + /// + /// The network interface ID. + /// + [Input("networkInterfaceId")] + public Input? NetworkInterfaceId { get; set; } + + /// + /// STACKIT project ID to which the network interface attachment is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The server ID. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + public ServerNetworkInterfaceAttachState() + { + } + public static new ServerNetworkInterfaceAttachState Empty => new ServerNetworkInterfaceAttachState(); + } +} diff --git a/sdk/dotnet/ServerServiceAccountAttach.cs b/sdk/dotnet/ServerServiceAccountAttach.cs new file mode 100644 index 0000000..dfc1766 --- /dev/null +++ b/sdk/dotnet/ServerServiceAccountAttach.cs @@ -0,0 +1,134 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach")] + public partial class ServerServiceAccountAttach : global::Pulumi.CustomResource + { + /// + /// STACKIT project ID to which the service account attachment is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The server ID. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + /// + /// The service account email. + /// + [Output("serviceAccountEmail")] + public Output ServiceAccountEmail { get; private set; } = null!; + + + /// + /// Create a ServerServiceAccountAttach 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 ServerServiceAccountAttach(string name, ServerServiceAccountAttachArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach", name, args ?? new ServerServiceAccountAttachArgs(), MakeResourceOptions(options, "")) + { + } + + private ServerServiceAccountAttach(string name, Input id, ServerServiceAccountAttachState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServerServiceAccountAttach 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 ServerServiceAccountAttach Get(string name, Input id, ServerServiceAccountAttachState? state = null, CustomResourceOptions? options = null) + { + return new ServerServiceAccountAttach(name, id, state, options); + } + } + + public sealed class ServerServiceAccountAttachArgs : global::Pulumi.ResourceArgs + { + /// + /// STACKIT project ID to which the service account attachment is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The server ID. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + /// + /// The service account email. + /// + [Input("serviceAccountEmail", required: true)] + public Input ServiceAccountEmail { get; set; } = null!; + + public ServerServiceAccountAttachArgs() + { + } + public static new ServerServiceAccountAttachArgs Empty => new ServerServiceAccountAttachArgs(); + } + + public sealed class ServerServiceAccountAttachState : global::Pulumi.ResourceArgs + { + /// + /// STACKIT project ID to which the service account attachment is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The server ID. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + /// + /// The service account email. + /// + [Input("serviceAccountEmail")] + public Input? ServiceAccountEmail { get; set; } + + public ServerServiceAccountAttachState() + { + } + public static new ServerServiceAccountAttachState Empty => new ServerServiceAccountAttachState(); + } +} diff --git a/sdk/dotnet/ServerUpdateSchedule.cs b/sdk/dotnet/ServerUpdateSchedule.cs new file mode 100644 index 0000000..5b40977 --- /dev/null +++ b/sdk/dotnet/ServerUpdateSchedule.cs @@ -0,0 +1,220 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Server update schedule resource schema. Must have a `region` specified in the provider configuration. + /// + /// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serverUpdateSchedule:ServerUpdateSchedule")] + public partial class ServerUpdateSchedule : global::Pulumi.CustomResource + { + /// + /// Is the update schedule enabled or disabled. + /// + [Output("enabled")] + public Output Enabled { get; private set; } = null!; + + /// + /// Maintenance window [1..24]. + /// + [Output("maintenanceWindow")] + public Output MaintenanceWindow { get; private set; } = null!; + + /// + /// The schedule name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Update schedule described in `rrule` (recurrence rule) format. + /// + [Output("rrule")] + public Output Rrule { get; private set; } = null!; + + /// + /// Server ID for the update schedule. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + /// + /// Update schedule ID. + /// + [Output("updateScheduleId")] + public Output UpdateScheduleId { get; private set; } = null!; + + + /// + /// Create a ServerUpdateSchedule 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 ServerUpdateSchedule(string name, ServerUpdateScheduleArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serverUpdateSchedule:ServerUpdateSchedule", name, args ?? new ServerUpdateScheduleArgs(), MakeResourceOptions(options, "")) + { + } + + private ServerUpdateSchedule(string name, Input id, ServerUpdateScheduleState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serverUpdateSchedule:ServerUpdateSchedule", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServerUpdateSchedule 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 ServerUpdateSchedule Get(string name, Input id, ServerUpdateScheduleState? state = null, CustomResourceOptions? options = null) + { + return new ServerUpdateSchedule(name, id, state, options); + } + } + + public sealed class ServerUpdateScheduleArgs : global::Pulumi.ResourceArgs + { + /// + /// Is the update schedule enabled or disabled. + /// + [Input("enabled", required: true)] + public Input Enabled { get; set; } = null!; + + /// + /// Maintenance window [1..24]. + /// + [Input("maintenanceWindow", required: true)] + public Input MaintenanceWindow { get; set; } = null!; + + /// + /// The schedule name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Update schedule described in `rrule` (recurrence rule) format. + /// + [Input("rrule", required: true)] + public Input Rrule { get; set; } = null!; + + /// + /// Server ID for the update schedule. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + public ServerUpdateScheduleArgs() + { + } + public static new ServerUpdateScheduleArgs Empty => new ServerUpdateScheduleArgs(); + } + + public sealed class ServerUpdateScheduleState : global::Pulumi.ResourceArgs + { + /// + /// Is the update schedule enabled or disabled. + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// Maintenance window [1..24]. + /// + [Input("maintenanceWindow")] + public Input? MaintenanceWindow { get; set; } + + /// + /// The schedule name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT Project ID to which the server is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + /// + /// Update schedule described in `rrule` (recurrence rule) format. + /// + [Input("rrule")] + public Input? Rrule { get; set; } + + /// + /// Server ID for the update schedule. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + /// + /// Update schedule ID. + /// + [Input("updateScheduleId")] + public Input? UpdateScheduleId { get; set; } + + public ServerUpdateScheduleState() + { + } + public static new ServerUpdateScheduleState Empty => new ServerUpdateScheduleState(); + } +} diff --git a/sdk/dotnet/ServerVolumeAttach.cs b/sdk/dotnet/ServerVolumeAttach.cs new file mode 100644 index 0000000..a990730 --- /dev/null +++ b/sdk/dotnet/ServerVolumeAttach.cs @@ -0,0 +1,134 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serverVolumeAttach:ServerVolumeAttach")] + public partial class ServerVolumeAttach : global::Pulumi.CustomResource + { + /// + /// STACKIT project ID to which the volume attachment is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The server ID. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + /// + /// The volume ID. + /// + [Output("volumeId")] + public Output VolumeId { get; private set; } = null!; + + + /// + /// Create a ServerVolumeAttach 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 ServerVolumeAttach(string name, ServerVolumeAttachArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serverVolumeAttach:ServerVolumeAttach", name, args ?? new ServerVolumeAttachArgs(), MakeResourceOptions(options, "")) + { + } + + private ServerVolumeAttach(string name, Input id, ServerVolumeAttachState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serverVolumeAttach:ServerVolumeAttach", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServerVolumeAttach 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 ServerVolumeAttach Get(string name, Input id, ServerVolumeAttachState? state = null, CustomResourceOptions? options = null) + { + return new ServerVolumeAttach(name, id, state, options); + } + } + + public sealed class ServerVolumeAttachArgs : global::Pulumi.ResourceArgs + { + /// + /// STACKIT project ID to which the volume attachment is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The server ID. + /// + [Input("serverId", required: true)] + public Input ServerId { get; set; } = null!; + + /// + /// The volume ID. + /// + [Input("volumeId", required: true)] + public Input VolumeId { get; set; } = null!; + + public ServerVolumeAttachArgs() + { + } + public static new ServerVolumeAttachArgs Empty => new ServerVolumeAttachArgs(); + } + + public sealed class ServerVolumeAttachState : global::Pulumi.ResourceArgs + { + /// + /// STACKIT project ID to which the volume attachment is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The server ID. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + /// + /// The volume ID. + /// + [Input("volumeId")] + public Input? VolumeId { get; set; } + + public ServerVolumeAttachState() + { + } + public static new ServerVolumeAttachState Empty => new ServerVolumeAttachState(); + } +} diff --git a/sdk/dotnet/ServiceAccount.cs b/sdk/dotnet/ServiceAccount.cs new file mode 100644 index 0000000..ce59ed5 --- /dev/null +++ b/sdk/dotnet/ServiceAccount.cs @@ -0,0 +1,128 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Service account resource schema. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/serviceAccount:ServiceAccount")] + public partial class ServiceAccount : global::Pulumi.CustomResource + { + /// + /// Email of the service account. + /// + [Output("email")] + public Output Email { get; private set; } = null!; + + /// + /// Name of the service account. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// STACKIT project ID to which the service account is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + + /// + /// Create a ServiceAccount 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 ServiceAccount(string name, ServiceAccountArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccount:ServiceAccount", name, args ?? new ServiceAccountArgs(), MakeResourceOptions(options, "")) + { + } + + private ServiceAccount(string name, Input id, ServiceAccountState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccount:ServiceAccount", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 ServiceAccount 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 ServiceAccount Get(string name, Input id, ServiceAccountState? state = null, CustomResourceOptions? options = null) + { + return new ServiceAccount(name, id, state, options); + } + } + + public sealed class ServiceAccountArgs : global::Pulumi.ResourceArgs + { + /// + /// Name of the service account. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the service account is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + public ServiceAccountArgs() + { + } + public static new ServiceAccountArgs Empty => new ServiceAccountArgs(); + } + + public sealed class ServiceAccountState : global::Pulumi.ResourceArgs + { + /// + /// Email of the service account. + /// + [Input("email")] + public Input? Email { get; set; } + + /// + /// Name of the service account. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// STACKIT project ID to which the service account is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + public ServiceAccountState() + { + } + public static new ServiceAccountState Empty => new ServiceAccountState(); + } +} diff --git a/sdk/dotnet/ServiceAccountAccessToken.cs b/sdk/dotnet/ServiceAccountAccessToken.cs new file mode 100644 index 0000000..177157d --- /dev/null +++ b/sdk/dotnet/ServiceAccountAccessToken.cs @@ -0,0 +1,239 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Service account access token schema. + /// ## Example Usage + /// + /// ### Automatically rotate access tokens + /// + [StackitResourceType("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken")] + public partial class ServiceAccountAccessToken : global::Pulumi.CustomResource + { + /// + /// Identifier for the access token linked to the service account. + /// + [Output("accessTokenId")] + public Output AccessTokenId { get; private set; } = null!; + + /// + /// Indicate whether the token is currently active or inactive + /// + [Output("active")] + public Output Active { get; private set; } = null!; + + /// + /// Timestamp indicating when the access token was created. + /// + [Output("createdAt")] + public Output CreatedAt { get; private set; } = null!; + + /// + /// STACKIT project ID associated with the service account token. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + [Output("rotateWhenChanged")] + public Output?> RotateWhenChanged { get; private set; } = null!; + + /// + /// Email address linked to the service account. + /// + [Output("serviceAccountEmail")] + public Output ServiceAccountEmail { get; private set; } = null!; + + /// + /// JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + /// + [Output("token")] + public Output Token { get; private set; } = null!; + + /// + /// Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + /// + [Output("ttlDays")] + public Output TtlDays { get; private set; } = null!; + + /// + /// Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + /// + [Output("validUntil")] + public Output ValidUntil { get; private set; } = null!; + + + /// + /// Create a ServiceAccountAccessToken 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 ServiceAccountAccessToken(string name, ServiceAccountAccessTokenArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken", name, args ?? new ServiceAccountAccessTokenArgs(), MakeResourceOptions(options, "")) + { + } + + private ServiceAccountAccessToken(string name, Input id, ServiceAccountAccessTokenState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "token", + }, + }; + 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 ServiceAccountAccessToken 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 ServiceAccountAccessToken Get(string name, Input id, ServiceAccountAccessTokenState? state = null, CustomResourceOptions? options = null) + { + return new ServiceAccountAccessToken(name, id, state, options); + } + } + + public sealed class ServiceAccountAccessTokenArgs : global::Pulumi.ResourceArgs + { + /// + /// STACKIT project ID associated with the service account token. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// Email address linked to the service account. + /// + [Input("serviceAccountEmail", required: true)] + public Input ServiceAccountEmail { get; set; } = null!; + + /// + /// Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + /// + [Input("ttlDays")] + public Input? TtlDays { get; set; } + + public ServiceAccountAccessTokenArgs() + { + } + public static new ServiceAccountAccessTokenArgs Empty => new ServiceAccountAccessTokenArgs(); + } + + public sealed class ServiceAccountAccessTokenState : global::Pulumi.ResourceArgs + { + /// + /// Identifier for the access token linked to the service account. + /// + [Input("accessTokenId")] + public Input? AccessTokenId { get; set; } + + /// + /// Indicate whether the token is currently active or inactive + /// + [Input("active")] + public Input? Active { get; set; } + + /// + /// Timestamp indicating when the access token was created. + /// + [Input("createdAt")] + public Input? CreatedAt { get; set; } + + /// + /// STACKIT project ID associated with the service account token. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// Email address linked to the service account. + /// + [Input("serviceAccountEmail")] + public Input? ServiceAccountEmail { get; set; } + + [Input("token")] + private Input? _token; + + /// + /// JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + /// + public Input? Token + { + get => _token; + set + { + var emptySecret = Output.CreateSecret(0); + _token = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + /// + [Input("ttlDays")] + public Input? TtlDays { get; set; } + + /// + /// Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + /// + [Input("validUntil")] + public Input? ValidUntil { get; set; } + + public ServiceAccountAccessTokenState() + { + } + public static new ServiceAccountAccessTokenState Empty => new ServiceAccountAccessTokenState(); + } +} diff --git a/sdk/dotnet/ServiceAccountKey.cs b/sdk/dotnet/ServiceAccountKey.cs new file mode 100644 index 0000000..893f2f1 --- /dev/null +++ b/sdk/dotnet/ServiceAccountKey.cs @@ -0,0 +1,221 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Service account key schema. + /// ## Example Usage + /// + /// ### Automatically rotate service account keys + /// + [StackitResourceType("stackit:index/serviceAccountKey:ServiceAccountKey")] + public partial class ServiceAccountKey : global::Pulumi.CustomResource + { + /// + /// The raw JSON representation of the service account key json, available for direct use. + /// + [Output("json")] + public Output Json { get; private set; } = null!; + + /// + /// The unique identifier for the key associated with the service account. + /// + [Output("keyId")] + public Output KeyId { get; private set; } = null!; + + /// + /// The STACKIT project ID associated with the service account key. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + /// + [Output("publicKey")] + public Output PublicKey { get; private set; } = null!; + + /// + /// A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + /// + [Output("rotateWhenChanged")] + public Output?> RotateWhenChanged { get; private set; } = null!; + + /// + /// The email address associated with the service account, used for account identification and communication. + /// + [Output("serviceAccountEmail")] + public Output ServiceAccountEmail { get; private set; } = null!; + + /// + /// Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + /// + [Output("ttlDays")] + public Output TtlDays { get; private set; } = null!; + + + /// + /// Create a ServiceAccountKey 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 ServiceAccountKey(string name, ServiceAccountKeyArgs args, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccountKey:ServiceAccountKey", name, args ?? new ServiceAccountKeyArgs(), MakeResourceOptions(options, "")) + { + } + + private ServiceAccountKey(string name, Input id, ServiceAccountKeyState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/serviceAccountKey:ServiceAccountKey", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "json", + }, + }; + 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 ServiceAccountKey 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 ServiceAccountKey Get(string name, Input id, ServiceAccountKeyState? state = null, CustomResourceOptions? options = null) + { + return new ServiceAccountKey(name, id, state, options); + } + } + + public sealed class ServiceAccountKeyArgs : global::Pulumi.ResourceArgs + { + /// + /// The STACKIT project ID associated with the service account key. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + /// + [Input("publicKey")] + public Input? PublicKey { get; set; } + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// The email address associated with the service account, used for account identification and communication. + /// + [Input("serviceAccountEmail", required: true)] + public Input ServiceAccountEmail { get; set; } = null!; + + /// + /// Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + /// + [Input("ttlDays")] + public Input? TtlDays { get; set; } + + public ServiceAccountKeyArgs() + { + } + public static new ServiceAccountKeyArgs Empty => new ServiceAccountKeyArgs(); + } + + public sealed class ServiceAccountKeyState : global::Pulumi.ResourceArgs + { + [Input("json")] + private Input? _json; + + /// + /// The raw JSON representation of the service account key json, available for direct use. + /// + public Input? Json + { + get => _json; + set + { + var emptySecret = Output.CreateSecret(0); + _json = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + /// + /// The unique identifier for the key associated with the service account. + /// + [Input("keyId")] + public Input? KeyId { get; set; } + + /// + /// The STACKIT project ID associated with the service account key. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + /// + [Input("publicKey")] + public Input? PublicKey { get; set; } + + [Input("rotateWhenChanged")] + private InputMap? _rotateWhenChanged; + + /// + /// A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + /// + public InputMap RotateWhenChanged + { + get => _rotateWhenChanged ?? (_rotateWhenChanged = new InputMap()); + set => _rotateWhenChanged = value; + } + + /// + /// The email address associated with the service account, used for account identification and communication. + /// + [Input("serviceAccountEmail")] + public Input? ServiceAccountEmail { get; set; } + + /// + /// Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + /// + [Input("ttlDays")] + public Input? TtlDays { get; set; } + + public ServiceAccountKeyState() + { + } + public static new ServiceAccountKeyState Empty => new ServiceAccountKeyState(); + } +} diff --git a/sdk/dotnet/SkeCluster.cs b/sdk/dotnet/SkeCluster.cs new file mode 100644 index 0000000..840e0cb --- /dev/null +++ b/sdk/dotnet/SkeCluster.cs @@ -0,0 +1,340 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// SKE Cluster Resource schema. Must have a `region` specified in the provider configuration. + /// + /// > When updating `node_pools` of a `stackit.SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/skeCluster:SkeCluster")] + public partial class SkeCluster : global::Pulumi.CustomResource + { + /// + /// Flag to specify if privileged mode for containers is enabled or not. + /// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + /// Deprecated as of Kubernetes 1.25 and later + /// + [Output("allowPrivilegedContainers")] + public Output AllowPrivilegedContainers { get; private set; } = null!; + + /// + /// The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + /// + [Output("egressAddressRanges")] + public Output> EgressAddressRanges { get; private set; } = null!; + + /// + /// A single extensions block as defined below. + /// + [Output("extensions")] + public Output Extensions { get; private set; } = null!; + + /// + /// One or more hibernation block as defined below. + /// + [Output("hibernations")] + public Output> Hibernations { get; private set; } = null!; + + /// + /// Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + /// + [Output("kubernetesVersion")] + public Output KubernetesVersion { get; private set; } = null!; + + /// + /// The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + /// + [Output("kubernetesVersionMin")] + public Output KubernetesVersionMin { get; private set; } = null!; + + /// + /// Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Output("kubernetesVersionUsed")] + public Output KubernetesVersionUsed { get; private set; } = null!; + + /// + /// A single maintenance block as defined below. + /// + [Output("maintenance")] + public Output Maintenance { get; private set; } = null!; + + /// + /// The cluster name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// Network block as defined below. + /// + [Output("network")] + public Output Network { get; private set; } = null!; + + /// + /// One or more `node_pool` block as defined below. + /// + [Output("nodePools")] + public Output> NodePools { get; private set; } = null!; + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + + /// + /// Create a SkeCluster 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 SkeCluster(string name, SkeClusterArgs args, CustomResourceOptions? options = null) + : base("stackit:index/skeCluster:SkeCluster", name, args ?? new SkeClusterArgs(), MakeResourceOptions(options, "")) + { + } + + private SkeCluster(string name, Input id, SkeClusterState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/skeCluster:SkeCluster", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 SkeCluster 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 SkeCluster Get(string name, Input id, SkeClusterState? state = null, CustomResourceOptions? options = null) + { + return new SkeCluster(name, id, state, options); + } + } + + public sealed class SkeClusterArgs : global::Pulumi.ResourceArgs + { + /// + /// Flag to specify if privileged mode for containers is enabled or not. + /// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + /// Deprecated as of Kubernetes 1.25 and later + /// + [Input("allowPrivilegedContainers")] + public Input? AllowPrivilegedContainers { get; set; } + + /// + /// A single extensions block as defined below. + /// + [Input("extensions")] + public Input? Extensions { get; set; } + + [Input("hibernations")] + private InputList? _hibernations; + + /// + /// One or more hibernation block as defined below. + /// + public InputList Hibernations + { + get => _hibernations ?? (_hibernations = new InputList()); + set => _hibernations = value; + } + + /// + /// Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + /// + [Input("kubernetesVersion")] + public Input? KubernetesVersion { get; set; } + + /// + /// The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + /// + [Input("kubernetesVersionMin")] + public Input? KubernetesVersionMin { get; set; } + + /// + /// A single maintenance block as defined below. + /// + [Input("maintenance")] + public Input? Maintenance { get; set; } + + /// + /// The cluster name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Network block as defined below. + /// + [Input("network")] + public Input? Network { get; set; } + + [Input("nodePools", required: true)] + private InputList? _nodePools; + + /// + /// One or more `node_pool` block as defined below. + /// + public InputList NodePools + { + get => _nodePools ?? (_nodePools = new InputList()); + set => _nodePools = value; + } + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public SkeClusterArgs() + { + } + public static new SkeClusterArgs Empty => new SkeClusterArgs(); + } + + public sealed class SkeClusterState : global::Pulumi.ResourceArgs + { + /// + /// Flag to specify if privileged mode for containers is enabled or not. + /// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + /// Deprecated as of Kubernetes 1.25 and later + /// + [Input("allowPrivilegedContainers")] + public Input? AllowPrivilegedContainers { get; set; } + + [Input("egressAddressRanges")] + private InputList? _egressAddressRanges; + + /// + /// The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + /// + public InputList EgressAddressRanges + { + get => _egressAddressRanges ?? (_egressAddressRanges = new InputList()); + set => _egressAddressRanges = value; + } + + /// + /// A single extensions block as defined below. + /// + [Input("extensions")] + public Input? Extensions { get; set; } + + [Input("hibernations")] + private InputList? _hibernations; + + /// + /// One or more hibernation block as defined below. + /// + public InputList Hibernations + { + get => _hibernations ?? (_hibernations = new InputList()); + set => _hibernations = value; + } + + /// + /// Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + /// + [Input("kubernetesVersion")] + public Input? KubernetesVersion { get; set; } + + /// + /// The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + /// + [Input("kubernetesVersionMin")] + public Input? KubernetesVersionMin { get; set; } + + /// + /// Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + /// + [Input("kubernetesVersionUsed")] + public Input? KubernetesVersionUsed { get; set; } + + /// + /// A single maintenance block as defined below. + /// + [Input("maintenance")] + public Input? Maintenance { get; set; } + + /// + /// The cluster name. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// Network block as defined below. + /// + [Input("network")] + public Input? Network { get; set; } + + [Input("nodePools")] + private InputList? _nodePools; + + /// + /// One or more `node_pool` block as defined below. + /// + public InputList NodePools + { + get => _nodePools ?? (_nodePools = new InputList()); + set => _nodePools = value; + } + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + public SkeClusterState() + { + } + public static new SkeClusterState Empty => new SkeClusterState(); + } +} diff --git a/sdk/dotnet/SkeKubeconfig.cs b/sdk/dotnet/SkeKubeconfig.cs new file mode 100644 index 0000000..e162696 --- /dev/null +++ b/sdk/dotnet/SkeKubeconfig.cs @@ -0,0 +1,208 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/skeKubeconfig:SkeKubeconfig")] + public partial class SkeKubeconfig : global::Pulumi.CustomResource + { + /// + /// Name of the SKE cluster. + /// + [Output("clusterName")] + public Output ClusterName { get; private set; } = null!; + + /// + /// Date-time when the kubeconfig was created + /// + [Output("creationTime")] + public Output CreationTime { get; private set; } = null!; + + /// + /// Expiration time of the kubeconfig, in seconds. Defaults to `3600` + /// + [Output("expiration")] + public Output Expiration { get; private set; } = null!; + + /// + /// Timestamp when the kubeconfig expires + /// + [Output("expiresAt")] + public Output ExpiresAt { get; private set; } = null!; + + /// + /// Raw short-lived admin kubeconfig. + /// + [Output("kubeConfig")] + public Output KubeConfig { get; private set; } = null!; + + [Output("kubeConfigId")] + public Output KubeConfigId { get; private set; } = null!; + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + /// + [Output("refresh")] + public Output Refresh { get; private set; } = null!; + + + /// + /// Create a SkeKubeconfig 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 SkeKubeconfig(string name, SkeKubeconfigArgs args, CustomResourceOptions? options = null) + : base("stackit:index/skeKubeconfig:SkeKubeconfig", name, args ?? new SkeKubeconfigArgs(), MakeResourceOptions(options, "")) + { + } + + private SkeKubeconfig(string name, Input id, SkeKubeconfigState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/skeKubeconfig:SkeKubeconfig", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "kubeConfig", + }, + }; + 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 SkeKubeconfig 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 SkeKubeconfig Get(string name, Input id, SkeKubeconfigState? state = null, CustomResourceOptions? options = null) + { + return new SkeKubeconfig(name, id, state, options); + } + } + + public sealed class SkeKubeconfigArgs : global::Pulumi.ResourceArgs + { + /// + /// Name of the SKE cluster. + /// + [Input("clusterName", required: true)] + public Input ClusterName { get; set; } = null!; + + /// + /// Expiration time of the kubeconfig, in seconds. Defaults to `3600` + /// + [Input("expiration")] + public Input? Expiration { get; set; } + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + /// + [Input("refresh")] + public Input? Refresh { get; set; } + + public SkeKubeconfigArgs() + { + } + public static new SkeKubeconfigArgs Empty => new SkeKubeconfigArgs(); + } + + public sealed class SkeKubeconfigState : global::Pulumi.ResourceArgs + { + /// + /// Name of the SKE cluster. + /// + [Input("clusterName")] + public Input? ClusterName { get; set; } + + /// + /// Date-time when the kubeconfig was created + /// + [Input("creationTime")] + public Input? CreationTime { get; set; } + + /// + /// Expiration time of the kubeconfig, in seconds. Defaults to `3600` + /// + [Input("expiration")] + public Input? Expiration { get; set; } + + /// + /// Timestamp when the kubeconfig expires + /// + [Input("expiresAt")] + public Input? ExpiresAt { get; set; } + + [Input("kubeConfig")] + private Input? _kubeConfig; + + /// + /// Raw short-lived admin kubeconfig. + /// + public Input? KubeConfig + { + get => _kubeConfig; + set + { + var emptySecret = Output.CreateSecret(0); + _kubeConfig = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("kubeConfigId")] + public Input? KubeConfigId { get; set; } + + /// + /// STACKIT project ID to which the cluster is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + /// + [Input("refresh")] + public Input? Refresh { get; set; } + + public SkeKubeconfigState() + { + } + public static new SkeKubeconfigState Empty => new SkeKubeconfigState(); + } +} diff --git a/sdk/dotnet/SqlserverflexInstance.cs b/sdk/dotnet/SqlserverflexInstance.cs new file mode 100644 index 0000000..2d1896c --- /dev/null +++ b/sdk/dotnet/SqlserverflexInstance.cs @@ -0,0 +1,236 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/sqlserverflexInstance:SqlserverflexInstance")] + public partial class SqlserverflexInstance : global::Pulumi.CustomResource + { + /// + /// The Access Control List (ACL) for the SQLServer Flex instance. + /// + [Output("acls")] + public Output> Acls { get; private set; } = null!; + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + /// + [Output("backupSchedule")] + public Output BackupSchedule { get; private set; } = null!; + + [Output("flavor")] + public Output Flavor { get; private set; } = null!; + + /// + /// ID of the SQLServer Flex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Instance name. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + [Output("options")] + public Output Options { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Output("region")] + public Output Region { get; private set; } = null!; + + [Output("replicas")] + public Output Replicas { get; private set; } = null!; + + [Output("storage")] + public Output Storage { get; private set; } = null!; + + [Output("version")] + public Output Version { get; private set; } = null!; + + + /// + /// Create a SqlserverflexInstance 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 SqlserverflexInstance(string name, SqlserverflexInstanceArgs args, CustomResourceOptions? options = null) + : base("stackit:index/sqlserverflexInstance:SqlserverflexInstance", name, args ?? new SqlserverflexInstanceArgs(), MakeResourceOptions(options, "")) + { + } + + private SqlserverflexInstance(string name, Input id, SqlserverflexInstanceState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/sqlserverflexInstance:SqlserverflexInstance", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 SqlserverflexInstance 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 SqlserverflexInstance Get(string name, Input id, SqlserverflexInstanceState? state = null, CustomResourceOptions? options = null) + { + return new SqlserverflexInstance(name, id, state, options); + } + } + + public sealed class SqlserverflexInstanceArgs : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the SQLServer Flex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + /// + [Input("backupSchedule")] + public Input? BackupSchedule { get; set; } + + [Input("flavor", required: true)] + public Input Flavor { get; set; } = null!; + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("options")] + public Input? Options { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("storage")] + public Input? Storage { get; set; } + + [Input("version")] + public Input? Version { get; set; } + + public SqlserverflexInstanceArgs() + { + } + public static new SqlserverflexInstanceArgs Empty => new SqlserverflexInstanceArgs(); + } + + public sealed class SqlserverflexInstanceState : global::Pulumi.ResourceArgs + { + [Input("acls")] + private InputList? _acls; + + /// + /// The Access Control List (ACL) for the SQLServer Flex instance. + /// + public InputList Acls + { + get => _acls ?? (_acls = new InputList()); + set => _acls = value; + } + + /// + /// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + /// + [Input("backupSchedule")] + public Input? BackupSchedule { get; set; } + + [Input("flavor")] + public Input? Flavor { get; set; } + + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + /// + /// Instance name. + /// + [Input("name")] + public Input? Name { get; set; } + + [Input("options")] + public Input? Options { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The resource region. If not defined, the provider region is used. + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("replicas")] + public Input? Replicas { get; set; } + + [Input("storage")] + public Input? Storage { get; set; } + + [Input("version")] + public Input? Version { get; set; } + + public SqlserverflexInstanceState() + { + } + public static new SqlserverflexInstanceState Empty => new SqlserverflexInstanceState(); + } +} diff --git a/sdk/dotnet/SqlserverflexUser.cs b/sdk/dotnet/SqlserverflexUser.cs new file mode 100644 index 0000000..729febe --- /dev/null +++ b/sdk/dotnet/SqlserverflexUser.cs @@ -0,0 +1,223 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/sqlserverflexUser:SqlserverflexUser")] + public partial class SqlserverflexUser : global::Pulumi.CustomResource + { + [Output("host")] + public Output Host { get; private set; } = null!; + + /// + /// ID of the SQLServer Flex instance. + /// + [Output("instanceId")] + public Output InstanceId { get; private set; } = null!; + + /// + /// Password of the user account. + /// + [Output("password")] + public Output Password { get; private set; } = null!; + + [Output("port")] + public Output Port { get; private set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + [Output("region")] + public Output Region { get; private set; } = null!; + + /// + /// Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + /// + [Output("roles")] + public Output> Roles { get; private set; } = null!; + + /// + /// User ID. + /// + [Output("userId")] + public Output UserId { get; private set; } = null!; + + /// + /// Username of the SQLServer Flex instance. + /// + [Output("username")] + public Output Username { get; private set; } = null!; + + + /// + /// Create a SqlserverflexUser 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 SqlserverflexUser(string name, SqlserverflexUserArgs args, CustomResourceOptions? options = null) + : base("stackit:index/sqlserverflexUser:SqlserverflexUser", name, args ?? new SqlserverflexUserArgs(), MakeResourceOptions(options, "")) + { + } + + private SqlserverflexUser(string name, Input id, SqlserverflexUserState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/sqlserverflexUser:SqlserverflexUser", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + AdditionalSecretOutputs = + { + "password", + }, + }; + 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 SqlserverflexUser 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 SqlserverflexUser Get(string name, Input id, SqlserverflexUserState? state = null, CustomResourceOptions? options = null) + { + return new SqlserverflexUser(name, id, state, options); + } + } + + public sealed class SqlserverflexUserArgs : global::Pulumi.ResourceArgs + { + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId", required: true)] + public Input InstanceId { get; set; } = null!; + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + [Input("region")] + public Input? Region { get; set; } + + [Input("roles")] + private InputList? _roles; + + /// + /// Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + /// + /// Username of the SQLServer Flex instance. + /// + [Input("username", required: true)] + public Input Username { get; set; } = null!; + + public SqlserverflexUserArgs() + { + } + public static new SqlserverflexUserArgs Empty => new SqlserverflexUserArgs(); + } + + public sealed class SqlserverflexUserState : global::Pulumi.ResourceArgs + { + [Input("host")] + public Input? Host { get; set; } + + /// + /// ID of the SQLServer Flex instance. + /// + [Input("instanceId")] + public Input? InstanceId { get; set; } + + [Input("password")] + private Input? _password; + + /// + /// Password of the user account. + /// + public Input? Password + { + get => _password; + set + { + var emptySecret = Output.CreateSecret(0); + _password = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("port")] + public Input? Port { get; set; } + + /// + /// STACKIT project ID to which the instance is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + [Input("region")] + public Input? Region { get; set; } + + [Input("roles")] + private InputList? _roles; + + /// + /// Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + /// + public InputList Roles + { + get => _roles ?? (_roles = new InputList()); + set => _roles = value; + } + + /// + /// User ID. + /// + [Input("userId")] + public Input? UserId { get; set; } + + /// + /// Username of the SQLServer Flex instance. + /// + [Input("username")] + public Input? Username { get; set; } + + public SqlserverflexUserState() + { + } + public static new SqlserverflexUserState Empty => new SqlserverflexUserState(); + } +} diff --git a/sdk/dotnet/Utilities.cs b/sdk/dotnet/Utilities.cs new file mode 100644 index 0000000..19052ec --- /dev/null +++ b/sdk/dotnet/Utilities.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +namespace Pulumi.Stackit +{ + static class Utilities + { + public static string? GetEnv(params string[] names) + { + foreach (var n in names) + { + var value = global::System.Environment.GetEnvironmentVariable(n); + if (value != null) + { + return value; + } + } + return null; + } + + static string[] trueValues = { "1", "t", "T", "true", "TRUE", "True" }; + static string[] falseValues = { "0", "f", "F", "false", "FALSE", "False" }; + public static bool? GetEnvBoolean(params string[] names) + { + var s = GetEnv(names); + if (s != null) + { + if (global::System.Array.IndexOf(trueValues, s) != -1) + { + return true; + } + if (global::System.Array.IndexOf(falseValues, s) != -1) + { + return false; + } + } + return null; + } + + public static int? GetEnvInt32(params string[] names) => int.TryParse(GetEnv(names), out int v) ? (int?)v : null; + + public static double? GetEnvDouble(params string[] names) => double.TryParse(GetEnv(names), out double v) ? (double?)v : null; + + [global::System.Obsolete("Please use WithDefaults instead")] + public static global::Pulumi.InvokeOptions WithVersion(this global::Pulumi.InvokeOptions? options) + { + var dst = options ?? new global::Pulumi.InvokeOptions{}; + dst.Version = options?.Version ?? Version; + return dst; + } + + public static global::Pulumi.InvokeOptions WithDefaults(this global::Pulumi.InvokeOptions? src) + { + var dst = src ?? new global::Pulumi.InvokeOptions{}; + dst.Version = src?.Version ?? Version; + dst.PluginDownloadURL = src?.PluginDownloadURL ?? "github://api.github.com/stackitcloud/pulumi-stackit"; + return dst; + } + + public static global::Pulumi.InvokeOutputOptions WithDefaults(this global::Pulumi.InvokeOutputOptions? src) + { + var dst = src ?? new global::Pulumi.InvokeOutputOptions{}; + dst.Version = src?.Version ?? Version; + dst.PluginDownloadURL = src?.PluginDownloadURL ?? "github://api.github.com/stackitcloud/pulumi-stackit"; + return dst; + } + + private readonly static string version; + public static string Version => version; + + static Utilities() + { + var assembly = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(Utilities)).Assembly; + using var stream = assembly.GetManifestResourceStream("Pulumi.Stackit.version.txt"); + using var reader = new global::System.IO.StreamReader(stream ?? throw new global::System.NotSupportedException("Missing embedded version.txt file")); + version = reader.ReadToEnd().Trim(); + var parts = version.Split("\n"); + if (parts.Length == 2) + { + // The first part is the provider name. + version = parts[1].Trim(); + } + } + } + + internal sealed class StackitResourceTypeAttribute : global::Pulumi.ResourceTypeAttribute + { + public StackitResourceTypeAttribute(string type) : base(type, Utilities.Version) + { + } + } +} diff --git a/sdk/dotnet/Volume.cs b/sdk/dotnet/Volume.cs new file mode 100644 index 0000000..8c94f76 --- /dev/null +++ b/sdk/dotnet/Volume.cs @@ -0,0 +1,260 @@ +// *** WARNING: this file was generated by pulumi-language-dotnet. *** +// *** 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.Stackit +{ + /// + /// Volume resource schema. Must have a `region` specified in the provider configuration. + /// + /// ## Example Usage + /// + [StackitResourceType("stackit:index/volume:Volume")] + public partial class Volume : global::Pulumi.CustomResource + { + /// + /// The availability zone of the volume. + /// + [Output("availabilityZone")] + public Output AvailabilityZone { get; private set; } = null!; + + /// + /// The description of the volume. + /// + [Output("description")] + public Output Description { get; private set; } = null!; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + [Output("labels")] + public Output?> Labels { get; private set; } = null!; + + /// + /// The name of the volume. + /// + [Output("name")] + public Output Name { get; private set; } = null!; + + /// + /// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + /// + [Output("performanceClass")] + public Output PerformanceClass { get; private set; } = null!; + + /// + /// STACKIT project ID to which the volume is associated. + /// + [Output("projectId")] + public Output ProjectId { get; private set; } = null!; + + /// + /// The server ID of the server to which the volume is attached to. + /// + [Output("serverId")] + public Output ServerId { get; private set; } = null!; + + /// + /// The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + /// + [Output("size")] + public Output Size { get; private set; } = null!; + + /// + /// The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + /// + [Output("source")] + public Output Source { get; private set; } = null!; + + /// + /// The volume ID. + /// + [Output("volumeId")] + public Output VolumeId { get; private set; } = null!; + + + /// + /// Create a Volume 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 Volume(string name, VolumeArgs args, CustomResourceOptions? options = null) + : base("stackit:index/volume:Volume", name, args ?? new VolumeArgs(), MakeResourceOptions(options, "")) + { + } + + private Volume(string name, Input id, VolumeState? state = null, CustomResourceOptions? options = null) + : base("stackit:index/volume:Volume", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + PluginDownloadURL = "github://api.github.com/stackitcloud/pulumi-stackit", + }; + 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 Volume 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 Volume Get(string name, Input id, VolumeState? state = null, CustomResourceOptions? options = null) + { + return new Volume(name, id, state, options); + } + } + + public sealed class VolumeArgs : global::Pulumi.ResourceArgs + { + /// + /// The availability zone of the volume. + /// + [Input("availabilityZone", required: true)] + public Input AvailabilityZone { get; set; } = null!; + + /// + /// The description of the volume. + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the volume. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + /// + [Input("performanceClass")] + public Input? PerformanceClass { get; set; } + + /// + /// STACKIT project ID to which the volume is associated. + /// + [Input("projectId", required: true)] + public Input ProjectId { get; set; } = null!; + + /// + /// The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + /// + [Input("size")] + public Input? Size { get; set; } + + /// + /// The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + /// + [Input("source")] + public Input? Source { get; set; } + + public VolumeArgs() + { + } + public static new VolumeArgs Empty => new VolumeArgs(); + } + + public sealed class VolumeState : global::Pulumi.ResourceArgs + { + /// + /// The availability zone of the volume. + /// + [Input("availabilityZone")] + public Input? AvailabilityZone { get; set; } + + /// + /// The description of the volume. + /// + [Input("description")] + public Input? Description { get; set; } + + [Input("labels")] + private InputMap? _labels; + + /// + /// Labels are key-value string pairs which can be attached to a resource container + /// + public InputMap Labels + { + get => _labels ?? (_labels = new InputMap()); + set => _labels = value; + } + + /// + /// The name of the volume. + /// + [Input("name")] + public Input? Name { get; set; } + + /// + /// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + /// + [Input("performanceClass")] + public Input? PerformanceClass { get; set; } + + /// + /// STACKIT project ID to which the volume is associated. + /// + [Input("projectId")] + public Input? ProjectId { get; set; } + + /// + /// The server ID of the server to which the volume is attached to. + /// + [Input("serverId")] + public Input? ServerId { get; set; } + + /// + /// The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + /// + [Input("size")] + public Input? Size { get; set; } + + /// + /// The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + /// + [Input("source")] + public Input? Source { get; set; } + + /// + /// The volume ID. + /// + [Input("volumeId")] + public Input? VolumeId { get; set; } + + public VolumeState() + { + } + public static new VolumeState Empty => new VolumeState(); + } +} diff --git a/sdk/dotnet/logo.png b/sdk/dotnet/logo.png new file mode 100644 index 0000000..181f421 Binary files /dev/null and b/sdk/dotnet/logo.png differ diff --git a/sdk/dotnet/pulumi-plugin.json b/sdk/dotnet/pulumi-plugin.json new file mode 100644 index 0000000..60d9f21 --- /dev/null +++ b/sdk/dotnet/pulumi-plugin.json @@ -0,0 +1,5 @@ +{ + "resource": true, + "name": "stackit", + "server": "github://api.github.com/stackitcloud/pulumi-stackit" +} diff --git a/sdk/go.mod b/sdk/go.mod new file mode 100644 index 0000000..74ca503 --- /dev/null +++ b/sdk/go.mod @@ -0,0 +1,94 @@ +module github.com/stackitcloud/pulumi-stackit/sdk + +go 1.23.0 + +toolchain go1.23.10 + +require ( + github.com/blang/semver v3.5.1+incompatible + github.com/pulumi/pulumi/sdk/v3 v3.181.0 +) + +require ( + dario.cat/mergo v1.0.0 // indirect + github.com/BurntSushi/toml v1.2.1 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/ProtonMail/go-crypto v1.1.3 // indirect + github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect + github.com/agext/levenshtein v1.2.3 // indirect + github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect + github.com/apparentlymart/go-textseg/v15 v15.0.0 // indirect + github.com/atotto/clipboard v0.1.4 // indirect + github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect + github.com/charmbracelet/bubbles v0.16.1 // indirect + github.com/charmbracelet/bubbletea v0.25.0 // indirect + github.com/charmbracelet/lipgloss v0.7.1 // indirect + github.com/cheggaaa/pb v1.0.29 // indirect + github.com/cloudflare/circl v1.6.1 // indirect + github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 // indirect + github.com/cyphar/filepath-securejoin v0.3.6 // indirect + github.com/djherbis/times v1.5.0 // indirect + github.com/emirpasic/gods v1.18.1 // indirect + github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect + github.com/go-git/go-billy/v5 v5.6.1 // indirect + github.com/go-git/go-git/v5 v5.13.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/glog v1.2.4 // indirect + github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 // indirect + github.com/hashicorp/errwrap v1.1.0 // indirect + github.com/hashicorp/go-multierror v1.1.1 // indirect + github.com/hashicorp/hcl/v2 v2.22.0 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/kevinburke/ssh_config v1.2.0 // indirect + github.com/lucasb-eyer/go-colorful v1.2.0 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-localereader v0.0.1 // indirect + github.com/mattn/go-runewidth v0.0.15 // indirect + github.com/mitchellh/go-ps v1.0.0 // indirect + github.com/mitchellh/go-wordwrap v1.0.1 // indirect + github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect + github.com/muesli/cancelreader v0.2.2 // indirect + github.com/muesli/reflow v0.3.0 // indirect + github.com/muesli/termenv v0.15.2 // indirect + github.com/opentracing/basictracer-go v1.1.0 // indirect + github.com/opentracing/opentracing-go v1.2.0 // indirect + github.com/pgavlin/fx v0.1.6 // indirect + github.com/pjbgf/sha1cd v0.3.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pkg/term v1.1.0 // indirect + github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 // indirect + github.com/pulumi/esc v0.14.3 // indirect + github.com/rivo/uniseg v0.4.4 // indirect + github.com/rogpeppe/go-internal v1.12.0 // indirect + github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect + github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 // indirect + github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 // indirect + github.com/skeema/knownhosts v1.3.0 // indirect + github.com/spf13/cast v1.4.1 // indirect + github.com/spf13/cobra v1.8.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/texttheater/golang-levenshtein v1.0.1 // indirect + github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect + github.com/uber/jaeger-lib v2.4.1+incompatible // indirect + github.com/xanzy/ssh-agent v0.3.3 // indirect + github.com/zclconf/go-cty v1.13.2 // indirect + go.uber.org/atomic v1.9.0 // indirect + golang.org/x/crypto v0.39.0 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect + golang.org/x/mod v0.25.0 // indirect + golang.org/x/net v0.40.0 // indirect + golang.org/x/sync v0.15.0 // indirect + golang.org/x/sys v0.33.0 // indirect + golang.org/x/term v0.32.0 // indirect + golang.org/x/text v0.26.0 // indirect + golang.org/x/tools v0.33.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect + google.golang.org/grpc v1.67.1 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + lukechampine.com/frand v1.4.2 // indirect +) diff --git a/sdk/go.sum b/sdk/go.sum new file mode 100644 index 0000000..b475564 --- /dev/null +++ b/sdk/go.sum @@ -0,0 +1,284 @@ +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= +github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/HdrHistogram/hdrhistogram-go v1.1.2 h1:5IcZpTvzydCQeHzK4Ef/D5rrSqwxob0t8PQPMybUNFM= +github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= +github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk= +github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da h1:KjTM2ks9d14ZYCvmHS9iAKVt9AyzRSqNU1qabPih5BY= +github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da/go.mod h1:eHEWzANqSiWQsof+nXEI9bUVUyV6F53Fp89EuCh2EAA= +github.com/agext/levenshtein v1.2.3 h1:YB2fHEn0UJagG8T1rrWknE3ZQzWM06O8AMAatNn7lmo= +github.com/agext/levenshtein v1.2.3/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be h1:9AeTilPcZAjCFIImctFaOjnTIavg87rW78vTPkQqLI8= +github.com/anmitsu/go-shlex v0.0.0-20200514113438-38f4b401e2be/go.mod h1:ySMOLuWl6zY27l47sB3qLNK6tF2fkHG55UZxx8oIVo4= +github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw= +github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo= +github.com/apparentlymart/go-textseg/v15 v15.0.0 h1:uYvfpb3DyLSCGWnctWKGj857c6ew1u1fNQOlOtuGxQY= +github.com/apparentlymart/go-textseg/v15 v15.0.0/go.mod h1:K8XmNZdhEBkdlyDdvbmmsvpAG721bKi0joRfFdHIWJ4= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio= +github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= +github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= +github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= +github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k= +github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8= +github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= +github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY= +github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc= +github.com/charmbracelet/bubbletea v0.25.0 h1:bAfwk7jRz7FKFl9RzlIULPkStffg5k6pNt5dywy4TcM= +github.com/charmbracelet/bubbletea v0.25.0/go.mod h1:EN3QDR1T5ZdWmdfDzYcqOCAps45+QIJbLOBxmVNWNNg= +github.com/charmbracelet/lipgloss v0.7.1 h1:17WMwi7N1b1rVWOjMT+rCh7sQkvDU75B2hbZpc5Kc1E= +github.com/charmbracelet/lipgloss v0.7.1/go.mod h1:yG0k3giv8Qj8edTCbbg6AlQ5e8KNWpFujkNawKNhE2c= +github.com/cheggaaa/pb v1.0.29 h1:FckUN5ngEk2LpvuG0fw1GEFx6LtyY2pWI/Z2QgCnEYo= +github.com/cheggaaa/pb v1.0.29/go.mod h1:W40334L7FMC5JKWldsTWbdGjLo0RxUKK73K+TuPxX30= +github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0= +github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY= +github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk= +github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/cyphar/filepath-securejoin v0.3.6 h1:4d9N5ykBnSp5Xn2JkhocYDkOpURL/18CYMpo6xB9uWM= +github.com/cyphar/filepath-securejoin v0.3.6/go.mod h1:Sdj7gXlvMcPZsbhwhQ33GguGLDGQL7h7bg04C/+u9jI= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/djherbis/times v1.5.0 h1:79myA211VwPhFTqUk8xehWrsEO+zcIZj0zT8mXPVARU= +github.com/djherbis/times v1.5.0/go.mod h1:5q7FDLvbNg1L/KaBmPcWlVR9NmoKo3+ucqUA3ijQhA0= +github.com/elazarl/goproxy v1.2.3 h1:xwIyKHbaP5yfT6O9KIeYJR5549MXRQkoQMRXGztz8YQ= +github.com/elazarl/goproxy v1.2.3/go.mod h1:YfEbZtqP4AetfO6d40vWchF3znWX7C7Vd6ZMfdL8z64= +github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc= +github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ= +github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= +github.com/gliderlabs/ssh v0.3.8 h1:a4YXD1V7xMF9g5nTkdfnja3Sxy1PVDCj1Zg4Wb8vY6c= +github.com/gliderlabs/ssh v0.3.8/go.mod h1:xYoytBv1sV0aL3CavoDuJIQNURXkkfPA/wxQ1pL1fAU= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 h1:+zs/tPmkDkHx3U66DAb0lQFJrpS6731Oaa12ikc+DiI= +github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376/go.mod h1:an3vInlBmSxCcxctByoQdvwPiA7DTK7jaaFDBTtu0ic= +github.com/go-git/go-billy/v5 v5.6.1 h1:u+dcrgaguSSkbjzHwelEjc0Yj300NUevrrPphk/SoRA= +github.com/go-git/go-billy/v5 v5.6.1/go.mod h1:0AsLr1z2+Uksi4NlElmMblP5rPcDZNRCD8ujZCRR2BE= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399 h1:eMje31YglSBqCdIqdhKBW8lokaMrL3uTkpGYlE2OOT4= +github.com/go-git/go-git-fixtures/v4 v4.3.2-0.20231010084843-55a94097c399/go.mod h1:1OCfN199q1Jm3HZlxleg+Dw/mwps2Wbk9frAWm+4FII= +github.com/go-git/go-git/v5 v5.13.1 h1:DAQ9APonnlvSWpvolXWIuV6Q6zXy2wHbN4cVlNR5Q+M= +github.com/go-git/go-git/v5 v5.13.1/go.mod h1:qryJB4cSBoq3FRoBRf5A77joojuBcmPJ0qu3XXXVixc= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang/glog v1.2.4 h1:CNNw5U8lSiiBk7druxtSHHTsRWcxKoac6kZKm2peBBc= +github.com/golang/glog v1.2.4/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645 h1:MJG/KsmcqMwFAkh8mTnAwhyKoB+sTAnY4CACC110tbU= +github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= +github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= +github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= +github.com/hashicorp/hcl/v2 v2.22.0 h1:hkZ3nCtqeJsDhPRFz5EA9iwcG1hNWGePOTw6oyul12M= +github.com/hashicorp/hcl/v2 v2.22.0/go.mod h1:62ZYHrXgPoX8xBnzl8QzbWq4dyDsDtfCRgIq1rbJEvA= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= +github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4= +github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= +github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4= +github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88= +github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= +github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc= +github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg= +github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= +github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI= +github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo= +github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA= +github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo= +github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s= +github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8= +github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo= +github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8= +github.com/onsi/gomega v1.34.1 h1:EUMJIKUjM8sKjYbtxQI9A4z2o+rruxnzNvpknOXie6k= +github.com/onsi/gomega v1.34.1/go.mod h1:kU1QgUvBDLXBJq618Xvm2LUX6rSAfRaFRTcdOeDLwwY= +github.com/opentracing/basictracer-go v1.1.0 h1:Oa1fTSBvAl8pa3U+IJYqrKm0NALwH9OsgwOqDv4xJW0= +github.com/opentracing/basictracer-go v1.1.0/go.mod h1:V2HZueSJEp879yv285Aap1BS69fQMD+MNP1mRs6mBQc= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/pgavlin/fx v0.1.6 h1:r9jEg69DhNoCd3Xh0+5mIbdbS3PqWrVWujkY76MFRTU= +github.com/pgavlin/fx v0.1.6/go.mod h1:KWZJ6fqBBSh8GxHYqwYCf3rYE7Gp2p0N8tJp8xv9u9M= +github.com/pgavlin/fx/v2 v2.0.3 h1:ZBVklTFjxcWvBVPE+ti5qwnmTIQ0Gq6nuj3J5RKDtKk= +github.com/pgavlin/fx/v2 v2.0.3/go.mod h1:Cvnwqq0BopdHUJ7CU50h1XPeKrF4ZwdFj1nJLXbAjCE= +github.com/pjbgf/sha1cd v0.3.0 h1:4D5XXmUUBUl/xQ6IjCkEAbqXskkq/4O7LmGn0AqMDs4= +github.com/pjbgf/sha1cd v0.3.0/go.mod h1:nZ1rrWOcGJ5uZgEEVL1VUM9iRQiZvWdbZjkKyFzPPsI= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/term v1.1.0 h1:xIAAdCMh3QIAy+5FrE8Ad8XoDhEU4ufwbaSozViP9kk= +github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 h1:vkHw5I/plNdTr435cARxCW6q9gc0S/Yxz7Mkd38pOb0= +github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231/go.mod h1:murToZ2N9hNJzewjHBgfFdXhZKjY3z5cYC1VXk+lbFE= +github.com/pulumi/esc v0.14.3 h1:Zli+9LiSDT/W+Fsfr8tITxCo+5wn969tLrE4KLv44G8= +github.com/pulumi/esc v0.14.3/go.mod h1:XnSxlt5NkmuAj304l/gK4pRErFbtqq6XpfX1tYT9Jbc= +github.com/pulumi/pulumi/sdk/v3 v3.181.0 h1:6XeYlG/mymtutRXlggcCLtxqBJPGCHNUGgoj4mapZQw= +github.com/pulumi/pulumi/sdk/v3 v3.181.0/go.mod h1:YS7uQ+eoIV/Fco804Upv3jmz5pwo/MkLYmbGH3VgA9c= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= +github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI= +github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0 h1:TToq11gyfNlrMFZiYujSekIsPd9AmsA2Bj/iv+s4JHE= +github.com/santhosh-tekuri/jsonschema/v5 v5.0.0/go.mod h1:FKdcjfQW6rpZSnxxUvEA5H/cDPdvJ/SZJQLWWXWGrZ0= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3 h1:n661drycOFuPLCN3Uc8sB6B/s6Z4t2xvBgU1htSHuq8= +github.com/sergi/go-diff v1.3.2-0.20230802210424-5b0b94c5c0d3/go.mod h1:A0bzQcvG0E7Rwjx0REVgAGH58e96+X0MeOfepqsbeW4= +github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= +github.com/skeema/knownhosts v1.3.0 h1:AM+y0rI04VksttfwjkSTNQorvGqmwATnvnAHpSgc0LY= +github.com/skeema/knownhosts v1.3.0/go.mod h1:sPINvnADmT/qYH1kfv+ePMmOBTH6Tbl7b5LvTDjFK7M= +github.com/spf13/cast v1.4.1 h1:s0hze+J0196ZfEMTs80N7UlFt0BDuQ7Q+JDnHiMWKdA= +github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0= +github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/texttheater/golang-levenshtein v1.0.1 h1:+cRNoVrfiwufQPhoMzB6N0Yf/Mqajr6t1lOv8GyGE2U= +github.com/texttheater/golang-levenshtein v1.0.1/go.mod h1:PYAKrbF5sAiq9wd+H82hs7gNaen0CplQ9uvm6+enD/8= +github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o= +github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk= +github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg= +github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U= +github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= +github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/zclconf/go-cty v1.13.2 h1:4GvrUxe/QUDYuJKAav4EYqdM47/kZa672LwmXFmEKT0= +github.com/zclconf/go-cty v1.13.2/go.mod h1:YKQzy/7pZ7iq2jNFzy5go57xdxdWoLLpaEp4u238AE0= +go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= +go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM= +golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w= +golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200421231249-e086a090c8fd/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= +golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8= +golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= +golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg= +golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M= +golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc= +golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E= +google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME= +gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +lukechampine.com/frand v1.4.2 h1:RzFIpOvkMXuPMBb9maa4ND4wjBn71E1Jpf8BzJHMaVw= +lukechampine.com/frand v1.4.2/go.mod h1:4S/TM2ZgrKejMcKMbeLjISpJMO+/eZ1zu3vYX9dtj3s= +pgregory.net/rapid v0.5.5 h1:jkgx1TjbQPD/feRoK+S/mXw9e1uj6WilpHrXJowi6oA= +pgregory.net/rapid v0.5.5/go.mod h1:PY5XlDGj0+V1FCq0o192FdRhpKHGTRIWBgqjDBTrq04= diff --git a/sdk/go/Pulumi.yaml b/sdk/go/Pulumi.yaml new file mode 100644 index 0000000..e69de29 diff --git a/sdk/go/stackit/affinityGroup.go b/sdk/go/stackit/affinityGroup.go new file mode 100644 index 0000000..d3ac116 --- /dev/null +++ b/sdk/go/stackit/affinityGroup.go @@ -0,0 +1,276 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Affinity Group schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type AffinityGroup struct { + pulumi.CustomResourceState + + // The affinity group ID. + AffinityGroupId pulumi.StringOutput `pulumi:"affinityGroupId"` + // The servers that are part of the affinity group. + Members pulumi.StringArrayOutput `pulumi:"members"` + // The name of the affinity group. + Name pulumi.StringOutput `pulumi:"name"` + // The policy of the affinity group. + Policy pulumi.StringOutput `pulumi:"policy"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` +} + +// NewAffinityGroup registers a new resource with the given unique name, arguments, and options. +func NewAffinityGroup(ctx *pulumi.Context, + name string, args *AffinityGroupArgs, opts ...pulumi.ResourceOption) (*AffinityGroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Policy == nil { + return nil, errors.New("invalid value for required argument 'Policy'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource AffinityGroup + err := ctx.RegisterResource("stackit:index/affinityGroup:AffinityGroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetAffinityGroup gets an existing AffinityGroup 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 GetAffinityGroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *AffinityGroupState, opts ...pulumi.ResourceOption) (*AffinityGroup, error) { + var resource AffinityGroup + err := ctx.ReadResource("stackit:index/affinityGroup:AffinityGroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering AffinityGroup resources. +type affinityGroupState struct { + // The affinity group ID. + AffinityGroupId *string `pulumi:"affinityGroupId"` + // The servers that are part of the affinity group. + Members []string `pulumi:"members"` + // The name of the affinity group. + Name *string `pulumi:"name"` + // The policy of the affinity group. + Policy *string `pulumi:"policy"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId *string `pulumi:"projectId"` +} + +type AffinityGroupState struct { + // The affinity group ID. + AffinityGroupId pulumi.StringPtrInput + // The servers that are part of the affinity group. + Members pulumi.StringArrayInput + // The name of the affinity group. + Name pulumi.StringPtrInput + // The policy of the affinity group. + Policy pulumi.StringPtrInput + // STACKIT Project ID to which the affinity group is associated. + ProjectId pulumi.StringPtrInput +} + +func (AffinityGroupState) ElementType() reflect.Type { + return reflect.TypeOf((*affinityGroupState)(nil)).Elem() +} + +type affinityGroupArgs struct { + // The name of the affinity group. + Name *string `pulumi:"name"` + // The policy of the affinity group. + Policy string `pulumi:"policy"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a AffinityGroup resource. +type AffinityGroupArgs struct { + // The name of the affinity group. + Name pulumi.StringPtrInput + // The policy of the affinity group. + Policy pulumi.StringInput + // STACKIT Project ID to which the affinity group is associated. + ProjectId pulumi.StringInput +} + +func (AffinityGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*affinityGroupArgs)(nil)).Elem() +} + +type AffinityGroupInput interface { + pulumi.Input + + ToAffinityGroupOutput() AffinityGroupOutput + ToAffinityGroupOutputWithContext(ctx context.Context) AffinityGroupOutput +} + +func (*AffinityGroup) ElementType() reflect.Type { + return reflect.TypeOf((**AffinityGroup)(nil)).Elem() +} + +func (i *AffinityGroup) ToAffinityGroupOutput() AffinityGroupOutput { + return i.ToAffinityGroupOutputWithContext(context.Background()) +} + +func (i *AffinityGroup) ToAffinityGroupOutputWithContext(ctx context.Context) AffinityGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(AffinityGroupOutput) +} + +// AffinityGroupArrayInput is an input type that accepts AffinityGroupArray and AffinityGroupArrayOutput values. +// You can construct a concrete instance of `AffinityGroupArrayInput` via: +// +// AffinityGroupArray{ AffinityGroupArgs{...} } +type AffinityGroupArrayInput interface { + pulumi.Input + + ToAffinityGroupArrayOutput() AffinityGroupArrayOutput + ToAffinityGroupArrayOutputWithContext(context.Context) AffinityGroupArrayOutput +} + +type AffinityGroupArray []AffinityGroupInput + +func (AffinityGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AffinityGroup)(nil)).Elem() +} + +func (i AffinityGroupArray) ToAffinityGroupArrayOutput() AffinityGroupArrayOutput { + return i.ToAffinityGroupArrayOutputWithContext(context.Background()) +} + +func (i AffinityGroupArray) ToAffinityGroupArrayOutputWithContext(ctx context.Context) AffinityGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(AffinityGroupArrayOutput) +} + +// AffinityGroupMapInput is an input type that accepts AffinityGroupMap and AffinityGroupMapOutput values. +// You can construct a concrete instance of `AffinityGroupMapInput` via: +// +// AffinityGroupMap{ "key": AffinityGroupArgs{...} } +type AffinityGroupMapInput interface { + pulumi.Input + + ToAffinityGroupMapOutput() AffinityGroupMapOutput + ToAffinityGroupMapOutputWithContext(context.Context) AffinityGroupMapOutput +} + +type AffinityGroupMap map[string]AffinityGroupInput + +func (AffinityGroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AffinityGroup)(nil)).Elem() +} + +func (i AffinityGroupMap) ToAffinityGroupMapOutput() AffinityGroupMapOutput { + return i.ToAffinityGroupMapOutputWithContext(context.Background()) +} + +func (i AffinityGroupMap) ToAffinityGroupMapOutputWithContext(ctx context.Context) AffinityGroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(AffinityGroupMapOutput) +} + +type AffinityGroupOutput struct{ *pulumi.OutputState } + +func (AffinityGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**AffinityGroup)(nil)).Elem() +} + +func (o AffinityGroupOutput) ToAffinityGroupOutput() AffinityGroupOutput { + return o +} + +func (o AffinityGroupOutput) ToAffinityGroupOutputWithContext(ctx context.Context) AffinityGroupOutput { + return o +} + +// The affinity group ID. +func (o AffinityGroupOutput) AffinityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v *AffinityGroup) pulumi.StringOutput { return v.AffinityGroupId }).(pulumi.StringOutput) +} + +// The servers that are part of the affinity group. +func (o AffinityGroupOutput) Members() pulumi.StringArrayOutput { + return o.ApplyT(func(v *AffinityGroup) pulumi.StringArrayOutput { return v.Members }).(pulumi.StringArrayOutput) +} + +// The name of the affinity group. +func (o AffinityGroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *AffinityGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The policy of the affinity group. +func (o AffinityGroupOutput) Policy() pulumi.StringOutput { + return o.ApplyT(func(v *AffinityGroup) pulumi.StringOutput { return v.Policy }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the affinity group is associated. +func (o AffinityGroupOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *AffinityGroup) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +type AffinityGroupArrayOutput struct{ *pulumi.OutputState } + +func (AffinityGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AffinityGroup)(nil)).Elem() +} + +func (o AffinityGroupArrayOutput) ToAffinityGroupArrayOutput() AffinityGroupArrayOutput { + return o +} + +func (o AffinityGroupArrayOutput) ToAffinityGroupArrayOutputWithContext(ctx context.Context) AffinityGroupArrayOutput { + return o +} + +func (o AffinityGroupArrayOutput) Index(i pulumi.IntInput) AffinityGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AffinityGroup { + return vs[0].([]*AffinityGroup)[vs[1].(int)] + }).(AffinityGroupOutput) +} + +type AffinityGroupMapOutput struct{ *pulumi.OutputState } + +func (AffinityGroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AffinityGroup)(nil)).Elem() +} + +func (o AffinityGroupMapOutput) ToAffinityGroupMapOutput() AffinityGroupMapOutput { + return o +} + +func (o AffinityGroupMapOutput) ToAffinityGroupMapOutputWithContext(ctx context.Context) AffinityGroupMapOutput { + return o +} + +func (o AffinityGroupMapOutput) MapIndex(k pulumi.StringInput) AffinityGroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AffinityGroup { + return vs[0].(map[string]*AffinityGroup)[vs[1].(string)] + }).(AffinityGroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*AffinityGroupInput)(nil)).Elem(), &AffinityGroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*AffinityGroupArrayInput)(nil)).Elem(), AffinityGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*AffinityGroupMapInput)(nil)).Elem(), AffinityGroupMap{}) + pulumi.RegisterOutputType(AffinityGroupOutput{}) + pulumi.RegisterOutputType(AffinityGroupArrayOutput{}) + pulumi.RegisterOutputType(AffinityGroupMapOutput{}) +} diff --git a/sdk/go/stackit/authorizationOrganizationRoleAssignment.go b/sdk/go/stackit/authorizationOrganizationRoleAssignment.go new file mode 100644 index 0000000..50922f4 --- /dev/null +++ b/sdk/go/stackit/authorizationOrganizationRoleAssignment.go @@ -0,0 +1,259 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// organization Role Assignment resource schema. +// +// > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. +// +// ## Example Usage +type AuthorizationOrganizationRoleAssignment struct { + pulumi.CustomResourceState + + // organization Resource to assign the role to. + ResourceId pulumi.StringOutput `pulumi:"resourceId"` + // Role to be assigned + Role pulumi.StringOutput `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringOutput `pulumi:"subject"` +} + +// NewAuthorizationOrganizationRoleAssignment registers a new resource with the given unique name, arguments, and options. +func NewAuthorizationOrganizationRoleAssignment(ctx *pulumi.Context, + name string, args *AuthorizationOrganizationRoleAssignmentArgs, opts ...pulumi.ResourceOption) (*AuthorizationOrganizationRoleAssignment, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ResourceId == nil { + return nil, errors.New("invalid value for required argument 'ResourceId'") + } + if args.Role == nil { + return nil, errors.New("invalid value for required argument 'Role'") + } + if args.Subject == nil { + return nil, errors.New("invalid value for required argument 'Subject'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource AuthorizationOrganizationRoleAssignment + err := ctx.RegisterResource("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetAuthorizationOrganizationRoleAssignment gets an existing AuthorizationOrganizationRoleAssignment 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 GetAuthorizationOrganizationRoleAssignment(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *AuthorizationOrganizationRoleAssignmentState, opts ...pulumi.ResourceOption) (*AuthorizationOrganizationRoleAssignment, error) { + var resource AuthorizationOrganizationRoleAssignment + err := ctx.ReadResource("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering AuthorizationOrganizationRoleAssignment resources. +type authorizationOrganizationRoleAssignmentState struct { + // organization Resource to assign the role to. + ResourceId *string `pulumi:"resourceId"` + // Role to be assigned + Role *string `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject *string `pulumi:"subject"` +} + +type AuthorizationOrganizationRoleAssignmentState struct { + // organization Resource to assign the role to. + ResourceId pulumi.StringPtrInput + // Role to be assigned + Role pulumi.StringPtrInput + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringPtrInput +} + +func (AuthorizationOrganizationRoleAssignmentState) ElementType() reflect.Type { + return reflect.TypeOf((*authorizationOrganizationRoleAssignmentState)(nil)).Elem() +} + +type authorizationOrganizationRoleAssignmentArgs struct { + // organization Resource to assign the role to. + ResourceId string `pulumi:"resourceId"` + // Role to be assigned + Role string `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject string `pulumi:"subject"` +} + +// The set of arguments for constructing a AuthorizationOrganizationRoleAssignment resource. +type AuthorizationOrganizationRoleAssignmentArgs struct { + // organization Resource to assign the role to. + ResourceId pulumi.StringInput + // Role to be assigned + Role pulumi.StringInput + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringInput +} + +func (AuthorizationOrganizationRoleAssignmentArgs) ElementType() reflect.Type { + return reflect.TypeOf((*authorizationOrganizationRoleAssignmentArgs)(nil)).Elem() +} + +type AuthorizationOrganizationRoleAssignmentInput interface { + pulumi.Input + + ToAuthorizationOrganizationRoleAssignmentOutput() AuthorizationOrganizationRoleAssignmentOutput + ToAuthorizationOrganizationRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentOutput +} + +func (*AuthorizationOrganizationRoleAssignment) ElementType() reflect.Type { + return reflect.TypeOf((**AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (i *AuthorizationOrganizationRoleAssignment) ToAuthorizationOrganizationRoleAssignmentOutput() AuthorizationOrganizationRoleAssignmentOutput { + return i.ToAuthorizationOrganizationRoleAssignmentOutputWithContext(context.Background()) +} + +func (i *AuthorizationOrganizationRoleAssignment) ToAuthorizationOrganizationRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationOrganizationRoleAssignmentOutput) +} + +// AuthorizationOrganizationRoleAssignmentArrayInput is an input type that accepts AuthorizationOrganizationRoleAssignmentArray and AuthorizationOrganizationRoleAssignmentArrayOutput values. +// You can construct a concrete instance of `AuthorizationOrganizationRoleAssignmentArrayInput` via: +// +// AuthorizationOrganizationRoleAssignmentArray{ AuthorizationOrganizationRoleAssignmentArgs{...} } +type AuthorizationOrganizationRoleAssignmentArrayInput interface { + pulumi.Input + + ToAuthorizationOrganizationRoleAssignmentArrayOutput() AuthorizationOrganizationRoleAssignmentArrayOutput + ToAuthorizationOrganizationRoleAssignmentArrayOutputWithContext(context.Context) AuthorizationOrganizationRoleAssignmentArrayOutput +} + +type AuthorizationOrganizationRoleAssignmentArray []AuthorizationOrganizationRoleAssignmentInput + +func (AuthorizationOrganizationRoleAssignmentArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (i AuthorizationOrganizationRoleAssignmentArray) ToAuthorizationOrganizationRoleAssignmentArrayOutput() AuthorizationOrganizationRoleAssignmentArrayOutput { + return i.ToAuthorizationOrganizationRoleAssignmentArrayOutputWithContext(context.Background()) +} + +func (i AuthorizationOrganizationRoleAssignmentArray) ToAuthorizationOrganizationRoleAssignmentArrayOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationOrganizationRoleAssignmentArrayOutput) +} + +// AuthorizationOrganizationRoleAssignmentMapInput is an input type that accepts AuthorizationOrganizationRoleAssignmentMap and AuthorizationOrganizationRoleAssignmentMapOutput values. +// You can construct a concrete instance of `AuthorizationOrganizationRoleAssignmentMapInput` via: +// +// AuthorizationOrganizationRoleAssignmentMap{ "key": AuthorizationOrganizationRoleAssignmentArgs{...} } +type AuthorizationOrganizationRoleAssignmentMapInput interface { + pulumi.Input + + ToAuthorizationOrganizationRoleAssignmentMapOutput() AuthorizationOrganizationRoleAssignmentMapOutput + ToAuthorizationOrganizationRoleAssignmentMapOutputWithContext(context.Context) AuthorizationOrganizationRoleAssignmentMapOutput +} + +type AuthorizationOrganizationRoleAssignmentMap map[string]AuthorizationOrganizationRoleAssignmentInput + +func (AuthorizationOrganizationRoleAssignmentMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (i AuthorizationOrganizationRoleAssignmentMap) ToAuthorizationOrganizationRoleAssignmentMapOutput() AuthorizationOrganizationRoleAssignmentMapOutput { + return i.ToAuthorizationOrganizationRoleAssignmentMapOutputWithContext(context.Background()) +} + +func (i AuthorizationOrganizationRoleAssignmentMap) ToAuthorizationOrganizationRoleAssignmentMapOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationOrganizationRoleAssignmentMapOutput) +} + +type AuthorizationOrganizationRoleAssignmentOutput struct{ *pulumi.OutputState } + +func (AuthorizationOrganizationRoleAssignmentOutput) ElementType() reflect.Type { + return reflect.TypeOf((**AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationOrganizationRoleAssignmentOutput) ToAuthorizationOrganizationRoleAssignmentOutput() AuthorizationOrganizationRoleAssignmentOutput { + return o +} + +func (o AuthorizationOrganizationRoleAssignmentOutput) ToAuthorizationOrganizationRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentOutput { + return o +} + +// organization Resource to assign the role to. +func (o AuthorizationOrganizationRoleAssignmentOutput) ResourceId() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationOrganizationRoleAssignment) pulumi.StringOutput { return v.ResourceId }).(pulumi.StringOutput) +} + +// Role to be assigned +func (o AuthorizationOrganizationRoleAssignmentOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationOrganizationRoleAssignment) pulumi.StringOutput { return v.Role }).(pulumi.StringOutput) +} + +// Identifier of user, service account or client. Usually email address or name in case of clients +func (o AuthorizationOrganizationRoleAssignmentOutput) Subject() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationOrganizationRoleAssignment) pulumi.StringOutput { return v.Subject }).(pulumi.StringOutput) +} + +type AuthorizationOrganizationRoleAssignmentArrayOutput struct{ *pulumi.OutputState } + +func (AuthorizationOrganizationRoleAssignmentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationOrganizationRoleAssignmentArrayOutput) ToAuthorizationOrganizationRoleAssignmentArrayOutput() AuthorizationOrganizationRoleAssignmentArrayOutput { + return o +} + +func (o AuthorizationOrganizationRoleAssignmentArrayOutput) ToAuthorizationOrganizationRoleAssignmentArrayOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentArrayOutput { + return o +} + +func (o AuthorizationOrganizationRoleAssignmentArrayOutput) Index(i pulumi.IntInput) AuthorizationOrganizationRoleAssignmentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AuthorizationOrganizationRoleAssignment { + return vs[0].([]*AuthorizationOrganizationRoleAssignment)[vs[1].(int)] + }).(AuthorizationOrganizationRoleAssignmentOutput) +} + +type AuthorizationOrganizationRoleAssignmentMapOutput struct{ *pulumi.OutputState } + +func (AuthorizationOrganizationRoleAssignmentMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AuthorizationOrganizationRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationOrganizationRoleAssignmentMapOutput) ToAuthorizationOrganizationRoleAssignmentMapOutput() AuthorizationOrganizationRoleAssignmentMapOutput { + return o +} + +func (o AuthorizationOrganizationRoleAssignmentMapOutput) ToAuthorizationOrganizationRoleAssignmentMapOutputWithContext(ctx context.Context) AuthorizationOrganizationRoleAssignmentMapOutput { + return o +} + +func (o AuthorizationOrganizationRoleAssignmentMapOutput) MapIndex(k pulumi.StringInput) AuthorizationOrganizationRoleAssignmentOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AuthorizationOrganizationRoleAssignment { + return vs[0].(map[string]*AuthorizationOrganizationRoleAssignment)[vs[1].(string)] + }).(AuthorizationOrganizationRoleAssignmentOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationOrganizationRoleAssignmentInput)(nil)).Elem(), &AuthorizationOrganizationRoleAssignment{}) + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationOrganizationRoleAssignmentArrayInput)(nil)).Elem(), AuthorizationOrganizationRoleAssignmentArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationOrganizationRoleAssignmentMapInput)(nil)).Elem(), AuthorizationOrganizationRoleAssignmentMap{}) + pulumi.RegisterOutputType(AuthorizationOrganizationRoleAssignmentOutput{}) + pulumi.RegisterOutputType(AuthorizationOrganizationRoleAssignmentArrayOutput{}) + pulumi.RegisterOutputType(AuthorizationOrganizationRoleAssignmentMapOutput{}) +} diff --git a/sdk/go/stackit/authorizationProjectRoleAssignment.go b/sdk/go/stackit/authorizationProjectRoleAssignment.go new file mode 100644 index 0000000..cf6ccee --- /dev/null +++ b/sdk/go/stackit/authorizationProjectRoleAssignment.go @@ -0,0 +1,259 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// project Role Assignment resource schema. +// +// > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. +// +// ## Example Usage +type AuthorizationProjectRoleAssignment struct { + pulumi.CustomResourceState + + // project Resource to assign the role to. + ResourceId pulumi.StringOutput `pulumi:"resourceId"` + // Role to be assigned + Role pulumi.StringOutput `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringOutput `pulumi:"subject"` +} + +// NewAuthorizationProjectRoleAssignment registers a new resource with the given unique name, arguments, and options. +func NewAuthorizationProjectRoleAssignment(ctx *pulumi.Context, + name string, args *AuthorizationProjectRoleAssignmentArgs, opts ...pulumi.ResourceOption) (*AuthorizationProjectRoleAssignment, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ResourceId == nil { + return nil, errors.New("invalid value for required argument 'ResourceId'") + } + if args.Role == nil { + return nil, errors.New("invalid value for required argument 'Role'") + } + if args.Subject == nil { + return nil, errors.New("invalid value for required argument 'Subject'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource AuthorizationProjectRoleAssignment + err := ctx.RegisterResource("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetAuthorizationProjectRoleAssignment gets an existing AuthorizationProjectRoleAssignment 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 GetAuthorizationProjectRoleAssignment(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *AuthorizationProjectRoleAssignmentState, opts ...pulumi.ResourceOption) (*AuthorizationProjectRoleAssignment, error) { + var resource AuthorizationProjectRoleAssignment + err := ctx.ReadResource("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering AuthorizationProjectRoleAssignment resources. +type authorizationProjectRoleAssignmentState struct { + // project Resource to assign the role to. + ResourceId *string `pulumi:"resourceId"` + // Role to be assigned + Role *string `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject *string `pulumi:"subject"` +} + +type AuthorizationProjectRoleAssignmentState struct { + // project Resource to assign the role to. + ResourceId pulumi.StringPtrInput + // Role to be assigned + Role pulumi.StringPtrInput + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringPtrInput +} + +func (AuthorizationProjectRoleAssignmentState) ElementType() reflect.Type { + return reflect.TypeOf((*authorizationProjectRoleAssignmentState)(nil)).Elem() +} + +type authorizationProjectRoleAssignmentArgs struct { + // project Resource to assign the role to. + ResourceId string `pulumi:"resourceId"` + // Role to be assigned + Role string `pulumi:"role"` + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject string `pulumi:"subject"` +} + +// The set of arguments for constructing a AuthorizationProjectRoleAssignment resource. +type AuthorizationProjectRoleAssignmentArgs struct { + // project Resource to assign the role to. + ResourceId pulumi.StringInput + // Role to be assigned + Role pulumi.StringInput + // Identifier of user, service account or client. Usually email address or name in case of clients + Subject pulumi.StringInput +} + +func (AuthorizationProjectRoleAssignmentArgs) ElementType() reflect.Type { + return reflect.TypeOf((*authorizationProjectRoleAssignmentArgs)(nil)).Elem() +} + +type AuthorizationProjectRoleAssignmentInput interface { + pulumi.Input + + ToAuthorizationProjectRoleAssignmentOutput() AuthorizationProjectRoleAssignmentOutput + ToAuthorizationProjectRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentOutput +} + +func (*AuthorizationProjectRoleAssignment) ElementType() reflect.Type { + return reflect.TypeOf((**AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (i *AuthorizationProjectRoleAssignment) ToAuthorizationProjectRoleAssignmentOutput() AuthorizationProjectRoleAssignmentOutput { + return i.ToAuthorizationProjectRoleAssignmentOutputWithContext(context.Background()) +} + +func (i *AuthorizationProjectRoleAssignment) ToAuthorizationProjectRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationProjectRoleAssignmentOutput) +} + +// AuthorizationProjectRoleAssignmentArrayInput is an input type that accepts AuthorizationProjectRoleAssignmentArray and AuthorizationProjectRoleAssignmentArrayOutput values. +// You can construct a concrete instance of `AuthorizationProjectRoleAssignmentArrayInput` via: +// +// AuthorizationProjectRoleAssignmentArray{ AuthorizationProjectRoleAssignmentArgs{...} } +type AuthorizationProjectRoleAssignmentArrayInput interface { + pulumi.Input + + ToAuthorizationProjectRoleAssignmentArrayOutput() AuthorizationProjectRoleAssignmentArrayOutput + ToAuthorizationProjectRoleAssignmentArrayOutputWithContext(context.Context) AuthorizationProjectRoleAssignmentArrayOutput +} + +type AuthorizationProjectRoleAssignmentArray []AuthorizationProjectRoleAssignmentInput + +func (AuthorizationProjectRoleAssignmentArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (i AuthorizationProjectRoleAssignmentArray) ToAuthorizationProjectRoleAssignmentArrayOutput() AuthorizationProjectRoleAssignmentArrayOutput { + return i.ToAuthorizationProjectRoleAssignmentArrayOutputWithContext(context.Background()) +} + +func (i AuthorizationProjectRoleAssignmentArray) ToAuthorizationProjectRoleAssignmentArrayOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationProjectRoleAssignmentArrayOutput) +} + +// AuthorizationProjectRoleAssignmentMapInput is an input type that accepts AuthorizationProjectRoleAssignmentMap and AuthorizationProjectRoleAssignmentMapOutput values. +// You can construct a concrete instance of `AuthorizationProjectRoleAssignmentMapInput` via: +// +// AuthorizationProjectRoleAssignmentMap{ "key": AuthorizationProjectRoleAssignmentArgs{...} } +type AuthorizationProjectRoleAssignmentMapInput interface { + pulumi.Input + + ToAuthorizationProjectRoleAssignmentMapOutput() AuthorizationProjectRoleAssignmentMapOutput + ToAuthorizationProjectRoleAssignmentMapOutputWithContext(context.Context) AuthorizationProjectRoleAssignmentMapOutput +} + +type AuthorizationProjectRoleAssignmentMap map[string]AuthorizationProjectRoleAssignmentInput + +func (AuthorizationProjectRoleAssignmentMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (i AuthorizationProjectRoleAssignmentMap) ToAuthorizationProjectRoleAssignmentMapOutput() AuthorizationProjectRoleAssignmentMapOutput { + return i.ToAuthorizationProjectRoleAssignmentMapOutputWithContext(context.Background()) +} + +func (i AuthorizationProjectRoleAssignmentMap) ToAuthorizationProjectRoleAssignmentMapOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(AuthorizationProjectRoleAssignmentMapOutput) +} + +type AuthorizationProjectRoleAssignmentOutput struct{ *pulumi.OutputState } + +func (AuthorizationProjectRoleAssignmentOutput) ElementType() reflect.Type { + return reflect.TypeOf((**AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationProjectRoleAssignmentOutput) ToAuthorizationProjectRoleAssignmentOutput() AuthorizationProjectRoleAssignmentOutput { + return o +} + +func (o AuthorizationProjectRoleAssignmentOutput) ToAuthorizationProjectRoleAssignmentOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentOutput { + return o +} + +// project Resource to assign the role to. +func (o AuthorizationProjectRoleAssignmentOutput) ResourceId() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationProjectRoleAssignment) pulumi.StringOutput { return v.ResourceId }).(pulumi.StringOutput) +} + +// Role to be assigned +func (o AuthorizationProjectRoleAssignmentOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationProjectRoleAssignment) pulumi.StringOutput { return v.Role }).(pulumi.StringOutput) +} + +// Identifier of user, service account or client. Usually email address or name in case of clients +func (o AuthorizationProjectRoleAssignmentOutput) Subject() pulumi.StringOutput { + return o.ApplyT(func(v *AuthorizationProjectRoleAssignment) pulumi.StringOutput { return v.Subject }).(pulumi.StringOutput) +} + +type AuthorizationProjectRoleAssignmentArrayOutput struct{ *pulumi.OutputState } + +func (AuthorizationProjectRoleAssignmentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationProjectRoleAssignmentArrayOutput) ToAuthorizationProjectRoleAssignmentArrayOutput() AuthorizationProjectRoleAssignmentArrayOutput { + return o +} + +func (o AuthorizationProjectRoleAssignmentArrayOutput) ToAuthorizationProjectRoleAssignmentArrayOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentArrayOutput { + return o +} + +func (o AuthorizationProjectRoleAssignmentArrayOutput) Index(i pulumi.IntInput) AuthorizationProjectRoleAssignmentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AuthorizationProjectRoleAssignment { + return vs[0].([]*AuthorizationProjectRoleAssignment)[vs[1].(int)] + }).(AuthorizationProjectRoleAssignmentOutput) +} + +type AuthorizationProjectRoleAssignmentMapOutput struct{ *pulumi.OutputState } + +func (AuthorizationProjectRoleAssignmentMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AuthorizationProjectRoleAssignment)(nil)).Elem() +} + +func (o AuthorizationProjectRoleAssignmentMapOutput) ToAuthorizationProjectRoleAssignmentMapOutput() AuthorizationProjectRoleAssignmentMapOutput { + return o +} + +func (o AuthorizationProjectRoleAssignmentMapOutput) ToAuthorizationProjectRoleAssignmentMapOutputWithContext(ctx context.Context) AuthorizationProjectRoleAssignmentMapOutput { + return o +} + +func (o AuthorizationProjectRoleAssignmentMapOutput) MapIndex(k pulumi.StringInput) AuthorizationProjectRoleAssignmentOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AuthorizationProjectRoleAssignment { + return vs[0].(map[string]*AuthorizationProjectRoleAssignment)[vs[1].(string)] + }).(AuthorizationProjectRoleAssignmentOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationProjectRoleAssignmentInput)(nil)).Elem(), &AuthorizationProjectRoleAssignment{}) + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationProjectRoleAssignmentArrayInput)(nil)).Elem(), AuthorizationProjectRoleAssignmentArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*AuthorizationProjectRoleAssignmentMapInput)(nil)).Elem(), AuthorizationProjectRoleAssignmentMap{}) + pulumi.RegisterOutputType(AuthorizationProjectRoleAssignmentOutput{}) + pulumi.RegisterOutputType(AuthorizationProjectRoleAssignmentArrayOutput{}) + pulumi.RegisterOutputType(AuthorizationProjectRoleAssignmentMapOutput{}) +} diff --git a/sdk/go/stackit/cdnCustomDomain.go b/sdk/go/stackit/cdnCustomDomain.go new file mode 100644 index 0000000..ba6a5e5 --- /dev/null +++ b/sdk/go/stackit/cdnCustomDomain.go @@ -0,0 +1,272 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// CDN distribution data source schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +type CdnCustomDomain struct { + pulumi.CustomResourceState + + // CDN distribution ID + DistributionId pulumi.StringOutput `pulumi:"distributionId"` + // List of distribution errors + Errors pulumi.StringArrayOutput `pulumi:"errors"` + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Status of the distribution + Status pulumi.StringOutput `pulumi:"status"` +} + +// NewCdnCustomDomain registers a new resource with the given unique name, arguments, and options. +func NewCdnCustomDomain(ctx *pulumi.Context, + name string, args *CdnCustomDomainArgs, opts ...pulumi.ResourceOption) (*CdnCustomDomain, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.DistributionId == nil { + return nil, errors.New("invalid value for required argument 'DistributionId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource CdnCustomDomain + err := ctx.RegisterResource("stackit:index/cdnCustomDomain:CdnCustomDomain", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCdnCustomDomain gets an existing CdnCustomDomain 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 GetCdnCustomDomain(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CdnCustomDomainState, opts ...pulumi.ResourceOption) (*CdnCustomDomain, error) { + var resource CdnCustomDomain + err := ctx.ReadResource("stackit:index/cdnCustomDomain:CdnCustomDomain", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CdnCustomDomain resources. +type cdnCustomDomainState struct { + // CDN distribution ID + DistributionId *string `pulumi:"distributionId"` + // List of distribution errors + Errors []string `pulumi:"errors"` + Name *string `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId *string `pulumi:"projectId"` + // Status of the distribution + Status *string `pulumi:"status"` +} + +type CdnCustomDomainState struct { + // CDN distribution ID + DistributionId pulumi.StringPtrInput + // List of distribution errors + Errors pulumi.StringArrayInput + Name pulumi.StringPtrInput + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringPtrInput + // Status of the distribution + Status pulumi.StringPtrInput +} + +func (CdnCustomDomainState) ElementType() reflect.Type { + return reflect.TypeOf((*cdnCustomDomainState)(nil)).Elem() +} + +type cdnCustomDomainArgs struct { + // CDN distribution ID + DistributionId string `pulumi:"distributionId"` + Name *string `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a CdnCustomDomain resource. +type CdnCustomDomainArgs struct { + // CDN distribution ID + DistributionId pulumi.StringInput + Name pulumi.StringPtrInput + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringInput +} + +func (CdnCustomDomainArgs) ElementType() reflect.Type { + return reflect.TypeOf((*cdnCustomDomainArgs)(nil)).Elem() +} + +type CdnCustomDomainInput interface { + pulumi.Input + + ToCdnCustomDomainOutput() CdnCustomDomainOutput + ToCdnCustomDomainOutputWithContext(ctx context.Context) CdnCustomDomainOutput +} + +func (*CdnCustomDomain) ElementType() reflect.Type { + return reflect.TypeOf((**CdnCustomDomain)(nil)).Elem() +} + +func (i *CdnCustomDomain) ToCdnCustomDomainOutput() CdnCustomDomainOutput { + return i.ToCdnCustomDomainOutputWithContext(context.Background()) +} + +func (i *CdnCustomDomain) ToCdnCustomDomainOutputWithContext(ctx context.Context) CdnCustomDomainOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnCustomDomainOutput) +} + +// CdnCustomDomainArrayInput is an input type that accepts CdnCustomDomainArray and CdnCustomDomainArrayOutput values. +// You can construct a concrete instance of `CdnCustomDomainArrayInput` via: +// +// CdnCustomDomainArray{ CdnCustomDomainArgs{...} } +type CdnCustomDomainArrayInput interface { + pulumi.Input + + ToCdnCustomDomainArrayOutput() CdnCustomDomainArrayOutput + ToCdnCustomDomainArrayOutputWithContext(context.Context) CdnCustomDomainArrayOutput +} + +type CdnCustomDomainArray []CdnCustomDomainInput + +func (CdnCustomDomainArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CdnCustomDomain)(nil)).Elem() +} + +func (i CdnCustomDomainArray) ToCdnCustomDomainArrayOutput() CdnCustomDomainArrayOutput { + return i.ToCdnCustomDomainArrayOutputWithContext(context.Background()) +} + +func (i CdnCustomDomainArray) ToCdnCustomDomainArrayOutputWithContext(ctx context.Context) CdnCustomDomainArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnCustomDomainArrayOutput) +} + +// CdnCustomDomainMapInput is an input type that accepts CdnCustomDomainMap and CdnCustomDomainMapOutput values. +// You can construct a concrete instance of `CdnCustomDomainMapInput` via: +// +// CdnCustomDomainMap{ "key": CdnCustomDomainArgs{...} } +type CdnCustomDomainMapInput interface { + pulumi.Input + + ToCdnCustomDomainMapOutput() CdnCustomDomainMapOutput + ToCdnCustomDomainMapOutputWithContext(context.Context) CdnCustomDomainMapOutput +} + +type CdnCustomDomainMap map[string]CdnCustomDomainInput + +func (CdnCustomDomainMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CdnCustomDomain)(nil)).Elem() +} + +func (i CdnCustomDomainMap) ToCdnCustomDomainMapOutput() CdnCustomDomainMapOutput { + return i.ToCdnCustomDomainMapOutputWithContext(context.Background()) +} + +func (i CdnCustomDomainMap) ToCdnCustomDomainMapOutputWithContext(ctx context.Context) CdnCustomDomainMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnCustomDomainMapOutput) +} + +type CdnCustomDomainOutput struct{ *pulumi.OutputState } + +func (CdnCustomDomainOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CdnCustomDomain)(nil)).Elem() +} + +func (o CdnCustomDomainOutput) ToCdnCustomDomainOutput() CdnCustomDomainOutput { + return o +} + +func (o CdnCustomDomainOutput) ToCdnCustomDomainOutputWithContext(ctx context.Context) CdnCustomDomainOutput { + return o +} + +// CDN distribution ID +func (o CdnCustomDomainOutput) DistributionId() pulumi.StringOutput { + return o.ApplyT(func(v *CdnCustomDomain) pulumi.StringOutput { return v.DistributionId }).(pulumi.StringOutput) +} + +// List of distribution errors +func (o CdnCustomDomainOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v *CdnCustomDomain) pulumi.StringArrayOutput { return v.Errors }).(pulumi.StringArrayOutput) +} + +func (o CdnCustomDomainOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *CdnCustomDomain) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID associated with the distribution +func (o CdnCustomDomainOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *CdnCustomDomain) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Status of the distribution +func (o CdnCustomDomainOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v *CdnCustomDomain) pulumi.StringOutput { return v.Status }).(pulumi.StringOutput) +} + +type CdnCustomDomainArrayOutput struct{ *pulumi.OutputState } + +func (CdnCustomDomainArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CdnCustomDomain)(nil)).Elem() +} + +func (o CdnCustomDomainArrayOutput) ToCdnCustomDomainArrayOutput() CdnCustomDomainArrayOutput { + return o +} + +func (o CdnCustomDomainArrayOutput) ToCdnCustomDomainArrayOutputWithContext(ctx context.Context) CdnCustomDomainArrayOutput { + return o +} + +func (o CdnCustomDomainArrayOutput) Index(i pulumi.IntInput) CdnCustomDomainOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CdnCustomDomain { + return vs[0].([]*CdnCustomDomain)[vs[1].(int)] + }).(CdnCustomDomainOutput) +} + +type CdnCustomDomainMapOutput struct{ *pulumi.OutputState } + +func (CdnCustomDomainMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CdnCustomDomain)(nil)).Elem() +} + +func (o CdnCustomDomainMapOutput) ToCdnCustomDomainMapOutput() CdnCustomDomainMapOutput { + return o +} + +func (o CdnCustomDomainMapOutput) ToCdnCustomDomainMapOutputWithContext(ctx context.Context) CdnCustomDomainMapOutput { + return o +} + +func (o CdnCustomDomainMapOutput) MapIndex(k pulumi.StringInput) CdnCustomDomainOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CdnCustomDomain { + return vs[0].(map[string]*CdnCustomDomain)[vs[1].(string)] + }).(CdnCustomDomainOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CdnCustomDomainInput)(nil)).Elem(), &CdnCustomDomain{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnCustomDomainArrayInput)(nil)).Elem(), CdnCustomDomainArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnCustomDomainMapInput)(nil)).Elem(), CdnCustomDomainMap{}) + pulumi.RegisterOutputType(CdnCustomDomainOutput{}) + pulumi.RegisterOutputType(CdnCustomDomainArrayOutput{}) + pulumi.RegisterOutputType(CdnCustomDomainMapOutput{}) +} diff --git a/sdk/go/stackit/cdnDistribution.go b/sdk/go/stackit/cdnDistribution.go new file mode 100644 index 0000000..c7c9238 --- /dev/null +++ b/sdk/go/stackit/cdnDistribution.go @@ -0,0 +1,307 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// CDN distribution data source schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +type CdnDistribution struct { + pulumi.CustomResourceState + + // The distribution configuration + Config CdnDistributionConfigOutput `pulumi:"config"` + // Time when the distribution was created + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // CDN distribution ID + DistributionId pulumi.StringOutput `pulumi:"distributionId"` + // List of configured domains for the distribution + Domains CdnDistributionDomainArrayOutput `pulumi:"domains"` + // List of distribution errors + Errors pulumi.StringArrayOutput `pulumi:"errors"` + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Status of the distribution + Status pulumi.StringOutput `pulumi:"status"` + // Time when the distribution was last updated + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` +} + +// NewCdnDistribution registers a new resource with the given unique name, arguments, and options. +func NewCdnDistribution(ctx *pulumi.Context, + name string, args *CdnDistributionArgs, opts ...pulumi.ResourceOption) (*CdnDistribution, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Config == nil { + return nil, errors.New("invalid value for required argument 'Config'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource CdnDistribution + err := ctx.RegisterResource("stackit:index/cdnDistribution:CdnDistribution", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCdnDistribution gets an existing CdnDistribution 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 GetCdnDistribution(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CdnDistributionState, opts ...pulumi.ResourceOption) (*CdnDistribution, error) { + var resource CdnDistribution + err := ctx.ReadResource("stackit:index/cdnDistribution:CdnDistribution", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CdnDistribution resources. +type cdnDistributionState struct { + // The distribution configuration + Config *CdnDistributionConfig `pulumi:"config"` + // Time when the distribution was created + CreatedAt *string `pulumi:"createdAt"` + // CDN distribution ID + DistributionId *string `pulumi:"distributionId"` + // List of configured domains for the distribution + Domains []CdnDistributionDomain `pulumi:"domains"` + // List of distribution errors + Errors []string `pulumi:"errors"` + // STACKIT project ID associated with the distribution + ProjectId *string `pulumi:"projectId"` + // Status of the distribution + Status *string `pulumi:"status"` + // Time when the distribution was last updated + UpdatedAt *string `pulumi:"updatedAt"` +} + +type CdnDistributionState struct { + // The distribution configuration + Config CdnDistributionConfigPtrInput + // Time when the distribution was created + CreatedAt pulumi.StringPtrInput + // CDN distribution ID + DistributionId pulumi.StringPtrInput + // List of configured domains for the distribution + Domains CdnDistributionDomainArrayInput + // List of distribution errors + Errors pulumi.StringArrayInput + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringPtrInput + // Status of the distribution + Status pulumi.StringPtrInput + // Time when the distribution was last updated + UpdatedAt pulumi.StringPtrInput +} + +func (CdnDistributionState) ElementType() reflect.Type { + return reflect.TypeOf((*cdnDistributionState)(nil)).Elem() +} + +type cdnDistributionArgs struct { + // The distribution configuration + Config CdnDistributionConfig `pulumi:"config"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a CdnDistribution resource. +type CdnDistributionArgs struct { + // The distribution configuration + Config CdnDistributionConfigInput + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringInput +} + +func (CdnDistributionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*cdnDistributionArgs)(nil)).Elem() +} + +type CdnDistributionInput interface { + pulumi.Input + + ToCdnDistributionOutput() CdnDistributionOutput + ToCdnDistributionOutputWithContext(ctx context.Context) CdnDistributionOutput +} + +func (*CdnDistribution) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistribution)(nil)).Elem() +} + +func (i *CdnDistribution) ToCdnDistributionOutput() CdnDistributionOutput { + return i.ToCdnDistributionOutputWithContext(context.Background()) +} + +func (i *CdnDistribution) ToCdnDistributionOutputWithContext(ctx context.Context) CdnDistributionOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionOutput) +} + +// CdnDistributionArrayInput is an input type that accepts CdnDistributionArray and CdnDistributionArrayOutput values. +// You can construct a concrete instance of `CdnDistributionArrayInput` via: +// +// CdnDistributionArray{ CdnDistributionArgs{...} } +type CdnDistributionArrayInput interface { + pulumi.Input + + ToCdnDistributionArrayOutput() CdnDistributionArrayOutput + ToCdnDistributionArrayOutputWithContext(context.Context) CdnDistributionArrayOutput +} + +type CdnDistributionArray []CdnDistributionInput + +func (CdnDistributionArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CdnDistribution)(nil)).Elem() +} + +func (i CdnDistributionArray) ToCdnDistributionArrayOutput() CdnDistributionArrayOutput { + return i.ToCdnDistributionArrayOutputWithContext(context.Background()) +} + +func (i CdnDistributionArray) ToCdnDistributionArrayOutputWithContext(ctx context.Context) CdnDistributionArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionArrayOutput) +} + +// CdnDistributionMapInput is an input type that accepts CdnDistributionMap and CdnDistributionMapOutput values. +// You can construct a concrete instance of `CdnDistributionMapInput` via: +// +// CdnDistributionMap{ "key": CdnDistributionArgs{...} } +type CdnDistributionMapInput interface { + pulumi.Input + + ToCdnDistributionMapOutput() CdnDistributionMapOutput + ToCdnDistributionMapOutputWithContext(context.Context) CdnDistributionMapOutput +} + +type CdnDistributionMap map[string]CdnDistributionInput + +func (CdnDistributionMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CdnDistribution)(nil)).Elem() +} + +func (i CdnDistributionMap) ToCdnDistributionMapOutput() CdnDistributionMapOutput { + return i.ToCdnDistributionMapOutputWithContext(context.Background()) +} + +func (i CdnDistributionMap) ToCdnDistributionMapOutputWithContext(ctx context.Context) CdnDistributionMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionMapOutput) +} + +type CdnDistributionOutput struct{ *pulumi.OutputState } + +func (CdnDistributionOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistribution)(nil)).Elem() +} + +func (o CdnDistributionOutput) ToCdnDistributionOutput() CdnDistributionOutput { + return o +} + +func (o CdnDistributionOutput) ToCdnDistributionOutputWithContext(ctx context.Context) CdnDistributionOutput { + return o +} + +// The distribution configuration +func (o CdnDistributionOutput) Config() CdnDistributionConfigOutput { + return o.ApplyT(func(v *CdnDistribution) CdnDistributionConfigOutput { return v.Config }).(CdnDistributionConfigOutput) +} + +// Time when the distribution was created +func (o CdnDistributionOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// CDN distribution ID +func (o CdnDistributionOutput) DistributionId() pulumi.StringOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringOutput { return v.DistributionId }).(pulumi.StringOutput) +} + +// List of configured domains for the distribution +func (o CdnDistributionOutput) Domains() CdnDistributionDomainArrayOutput { + return o.ApplyT(func(v *CdnDistribution) CdnDistributionDomainArrayOutput { return v.Domains }).(CdnDistributionDomainArrayOutput) +} + +// List of distribution errors +func (o CdnDistributionOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringArrayOutput { return v.Errors }).(pulumi.StringArrayOutput) +} + +// STACKIT project ID associated with the distribution +func (o CdnDistributionOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Status of the distribution +func (o CdnDistributionOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringOutput { return v.Status }).(pulumi.StringOutput) +} + +// Time when the distribution was last updated +func (o CdnDistributionOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CdnDistribution) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type CdnDistributionArrayOutput struct{ *pulumi.OutputState } + +func (CdnDistributionArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CdnDistribution)(nil)).Elem() +} + +func (o CdnDistributionArrayOutput) ToCdnDistributionArrayOutput() CdnDistributionArrayOutput { + return o +} + +func (o CdnDistributionArrayOutput) ToCdnDistributionArrayOutputWithContext(ctx context.Context) CdnDistributionArrayOutput { + return o +} + +func (o CdnDistributionArrayOutput) Index(i pulumi.IntInput) CdnDistributionOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CdnDistribution { + return vs[0].([]*CdnDistribution)[vs[1].(int)] + }).(CdnDistributionOutput) +} + +type CdnDistributionMapOutput struct{ *pulumi.OutputState } + +func (CdnDistributionMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CdnDistribution)(nil)).Elem() +} + +func (o CdnDistributionMapOutput) ToCdnDistributionMapOutput() CdnDistributionMapOutput { + return o +} + +func (o CdnDistributionMapOutput) ToCdnDistributionMapOutputWithContext(ctx context.Context) CdnDistributionMapOutput { + return o +} + +func (o CdnDistributionMapOutput) MapIndex(k pulumi.StringInput) CdnDistributionOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CdnDistribution { + return vs[0].(map[string]*CdnDistribution)[vs[1].(string)] + }).(CdnDistributionOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionInput)(nil)).Elem(), &CdnDistribution{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionArrayInput)(nil)).Elem(), CdnDistributionArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionMapInput)(nil)).Elem(), CdnDistributionMap{}) + pulumi.RegisterOutputType(CdnDistributionOutput{}) + pulumi.RegisterOutputType(CdnDistributionArrayOutput{}) + pulumi.RegisterOutputType(CdnDistributionMapOutput{}) +} diff --git a/sdk/go/stackit/config/config.go b/sdk/go/stackit/config/config.go new file mode 100644 index 0000000..2538c1a --- /dev/null +++ b/sdk/go/stackit/config/config.go @@ -0,0 +1,209 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package config + +import ( + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +var _ = internal.GetEnvOrDefault + +// Custom endpoint for the Argus service +// +// Deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. +func GetArgusCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:argusCustomEndpoint") +} + +// Custom endpoint for the Membership service +func GetAuthorizationCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:authorizationCustomEndpoint") +} + +// Custom endpoint for the CDN service +func GetCdnCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:cdnCustomEndpoint") +} + +// Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default +// value is `~/.stackit/credentials.json`. +func GetCredentialsPath(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:credentialsPath") +} + +// Region will be used as the default location for regional services. Not all services require a region, some are global +func GetDefaultRegion(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:defaultRegion") +} + +// Custom endpoint for the DNS service +func GetDnsCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:dnsCustomEndpoint") +} + +// Enable beta resources. Default is false. +func GetEnableBetaResources(ctx *pulumi.Context) bool { + return config.GetBool(ctx, "stackit:enableBetaResources") +} + +// Enables experiments. These are unstable features without official support. More information can be found in the README. +// Available Experiments: [iam] +func GetExperiments(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:experiments") +} + +// Custom endpoint for the Git service +func GetGitCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:gitCustomEndpoint") +} + +// Custom endpoint for the IaaS service +func GetIaasCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:iaasCustomEndpoint") +} + +// Custom endpoint for the Load Balancer service +func GetLoadbalancerCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:loadbalancerCustomEndpoint") +} + +// Custom endpoint for the LogMe service +func GetLogmeCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:logmeCustomEndpoint") +} + +// Custom endpoint for the MariaDB service +func GetMariadbCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:mariadbCustomEndpoint") +} + +// Custom endpoint for the AI Model Serving service +func GetModelservingCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:modelservingCustomEndpoint") +} + +// Custom endpoint for the MongoDB Flex service +func GetMongodbflexCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:mongodbflexCustomEndpoint") +} + +// Custom endpoint for the Object Storage service +func GetObjectstorageCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:objectstorageCustomEndpoint") +} + +// Custom endpoint for the Observability service +func GetObservabilityCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:observabilityCustomEndpoint") +} + +// Custom endpoint for the OpenSearch service +func GetOpensearchCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:opensearchCustomEndpoint") +} + +// Custom endpoint for the PostgresFlex service +func GetPostgresflexCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:postgresflexCustomEndpoint") +} + +// Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is +// included in the service account key. +func GetPrivateKey(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:privateKey") +} + +// Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private +// key that is included in the service account key. +func GetPrivateKeyPath(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:privateKeyPath") +} + +// Custom endpoint for the RabbitMQ service +func GetRabbitmqCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:rabbitmqCustomEndpoint") +} + +// Custom endpoint for the Redis service +func GetRedisCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:redisCustomEndpoint") +} + +// Region will be used as the default location for regional services. Not all services require a region, some are global +// +// Deprecated: This attribute is deprecated. Use 'default_region' instead +func GetRegion(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:region") +} + +// Custom endpoint for the Resource Manager service +func GetResourcemanagerCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:resourcemanagerCustomEndpoint") +} + +// Custom endpoint for the Secrets Manager service +func GetSecretsmanagerCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:secretsmanagerCustomEndpoint") +} + +// Custom endpoint for the Server Backup service +func GetServerBackupCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serverBackupCustomEndpoint") +} + +// Custom endpoint for the Server Update service +func GetServerUpdateCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serverUpdateCustomEndpoint") +} + +// Custom endpoint for the Service Account service +func GetServiceAccountCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceAccountCustomEndpoint") +} + +// Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required +// if you want to use the resource manager project resource. +// +// Deprecated: The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. +func GetServiceAccountEmail(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceAccountEmail") +} + +// Service account key used for authentication. If set, the key flow will be used to authenticate all operations. +func GetServiceAccountKey(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceAccountKey") +} + +// Path for the service account key used for authentication. If set, the key flow will be used to authenticate all +// operations. +func GetServiceAccountKeyPath(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceAccountKeyPath") +} + +// Token used for authentication. If set, the token flow will be used to authenticate all operations. +func GetServiceAccountToken(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceAccountToken") +} + +// Custom endpoint for the Service Enablement API +func GetServiceEnablementCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:serviceEnablementCustomEndpoint") +} + +// Custom endpoint for the Kubernetes Engine (SKE) service +func GetSkeCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:skeCustomEndpoint") +} + +// Custom endpoint for the SQL Server Flex service +func GetSqlserverflexCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:sqlserverflexCustomEndpoint") +} + +// Custom endpoint for the token API, which is used to request access tokens when using the key flow +func GetTokenCustomEndpoint(ctx *pulumi.Context) string { + return config.Get(ctx, "stackit:tokenCustomEndpoint") +} diff --git a/sdk/go/stackit/dnsRecordSet.go b/sdk/go/stackit/dnsRecordSet.go new file mode 100644 index 0000000..99dd0e6 --- /dev/null +++ b/sdk/go/stackit/dnsRecordSet.go @@ -0,0 +1,379 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// DNS Record Set Resource schema. +// +// ## Example Usage +type DnsRecordSet struct { + pulumi.CustomResourceState + + // Specifies if the record set is active or not. Defaults to `true` + Active pulumi.BoolOutput `pulumi:"active"` + // Comment. + Comment pulumi.StringOutput `pulumi:"comment"` + // Error shows error in case create/update/delete failed. + Error pulumi.StringOutput `pulumi:"error"` + // Fully qualified domain name (FQDN) of the record set. + Fqdn pulumi.StringOutput `pulumi:"fqdn"` + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the dns record set is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The rr set id. + RecordSetId pulumi.StringOutput `pulumi:"recordSetId"` + // Records. + Records pulumi.StringArrayOutput `pulumi:"records"` + // Record set state. + State pulumi.StringOutput `pulumi:"state"` + // Time to live. E.g. 3600 + Ttl pulumi.IntOutput `pulumi:"ttl"` + // The record set type. E.g. `A` or `CNAME` + Type pulumi.StringOutput `pulumi:"type"` + // The zone ID to which is dns record set is associated. + ZoneId pulumi.StringOutput `pulumi:"zoneId"` +} + +// NewDnsRecordSet registers a new resource with the given unique name, arguments, and options. +func NewDnsRecordSet(ctx *pulumi.Context, + name string, args *DnsRecordSetArgs, opts ...pulumi.ResourceOption) (*DnsRecordSet, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Records == nil { + return nil, errors.New("invalid value for required argument 'Records'") + } + if args.Type == nil { + return nil, errors.New("invalid value for required argument 'Type'") + } + if args.ZoneId == nil { + return nil, errors.New("invalid value for required argument 'ZoneId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource DnsRecordSet + err := ctx.RegisterResource("stackit:index/dnsRecordSet:DnsRecordSet", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDnsRecordSet gets an existing DnsRecordSet 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 GetDnsRecordSet(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DnsRecordSetState, opts ...pulumi.ResourceOption) (*DnsRecordSet, error) { + var resource DnsRecordSet + err := ctx.ReadResource("stackit:index/dnsRecordSet:DnsRecordSet", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DnsRecordSet resources. +type dnsRecordSetState struct { + // Specifies if the record set is active or not. Defaults to `true` + Active *bool `pulumi:"active"` + // Comment. + Comment *string `pulumi:"comment"` + // Error shows error in case create/update/delete failed. + Error *string `pulumi:"error"` + // Fully qualified domain name (FQDN) of the record set. + Fqdn *string `pulumi:"fqdn"` + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name *string `pulumi:"name"` + // STACKIT project ID to which the dns record set is associated. + ProjectId *string `pulumi:"projectId"` + // The rr set id. + RecordSetId *string `pulumi:"recordSetId"` + // Records. + Records []string `pulumi:"records"` + // Record set state. + State *string `pulumi:"state"` + // Time to live. E.g. 3600 + Ttl *int `pulumi:"ttl"` + // The record set type. E.g. `A` or `CNAME` + Type *string `pulumi:"type"` + // The zone ID to which is dns record set is associated. + ZoneId *string `pulumi:"zoneId"` +} + +type DnsRecordSetState struct { + // Specifies if the record set is active or not. Defaults to `true` + Active pulumi.BoolPtrInput + // Comment. + Comment pulumi.StringPtrInput + // Error shows error in case create/update/delete failed. + Error pulumi.StringPtrInput + // Fully qualified domain name (FQDN) of the record set. + Fqdn pulumi.StringPtrInput + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name pulumi.StringPtrInput + // STACKIT project ID to which the dns record set is associated. + ProjectId pulumi.StringPtrInput + // The rr set id. + RecordSetId pulumi.StringPtrInput + // Records. + Records pulumi.StringArrayInput + // Record set state. + State pulumi.StringPtrInput + // Time to live. E.g. 3600 + Ttl pulumi.IntPtrInput + // The record set type. E.g. `A` or `CNAME` + Type pulumi.StringPtrInput + // The zone ID to which is dns record set is associated. + ZoneId pulumi.StringPtrInput +} + +func (DnsRecordSetState) ElementType() reflect.Type { + return reflect.TypeOf((*dnsRecordSetState)(nil)).Elem() +} + +type dnsRecordSetArgs struct { + // Specifies if the record set is active or not. Defaults to `true` + Active *bool `pulumi:"active"` + // Comment. + Comment *string `pulumi:"comment"` + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name *string `pulumi:"name"` + // STACKIT project ID to which the dns record set is associated. + ProjectId string `pulumi:"projectId"` + // Records. + Records []string `pulumi:"records"` + // Time to live. E.g. 3600 + Ttl *int `pulumi:"ttl"` + // The record set type. E.g. `A` or `CNAME` + Type string `pulumi:"type"` + // The zone ID to which is dns record set is associated. + ZoneId string `pulumi:"zoneId"` +} + +// The set of arguments for constructing a DnsRecordSet resource. +type DnsRecordSetArgs struct { + // Specifies if the record set is active or not. Defaults to `true` + Active pulumi.BoolPtrInput + // Comment. + Comment pulumi.StringPtrInput + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name pulumi.StringPtrInput + // STACKIT project ID to which the dns record set is associated. + ProjectId pulumi.StringInput + // Records. + Records pulumi.StringArrayInput + // Time to live. E.g. 3600 + Ttl pulumi.IntPtrInput + // The record set type. E.g. `A` or `CNAME` + Type pulumi.StringInput + // The zone ID to which is dns record set is associated. + ZoneId pulumi.StringInput +} + +func (DnsRecordSetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dnsRecordSetArgs)(nil)).Elem() +} + +type DnsRecordSetInput interface { + pulumi.Input + + ToDnsRecordSetOutput() DnsRecordSetOutput + ToDnsRecordSetOutputWithContext(ctx context.Context) DnsRecordSetOutput +} + +func (*DnsRecordSet) ElementType() reflect.Type { + return reflect.TypeOf((**DnsRecordSet)(nil)).Elem() +} + +func (i *DnsRecordSet) ToDnsRecordSetOutput() DnsRecordSetOutput { + return i.ToDnsRecordSetOutputWithContext(context.Background()) +} + +func (i *DnsRecordSet) ToDnsRecordSetOutputWithContext(ctx context.Context) DnsRecordSetOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsRecordSetOutput) +} + +// DnsRecordSetArrayInput is an input type that accepts DnsRecordSetArray and DnsRecordSetArrayOutput values. +// You can construct a concrete instance of `DnsRecordSetArrayInput` via: +// +// DnsRecordSetArray{ DnsRecordSetArgs{...} } +type DnsRecordSetArrayInput interface { + pulumi.Input + + ToDnsRecordSetArrayOutput() DnsRecordSetArrayOutput + ToDnsRecordSetArrayOutputWithContext(context.Context) DnsRecordSetArrayOutput +} + +type DnsRecordSetArray []DnsRecordSetInput + +func (DnsRecordSetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DnsRecordSet)(nil)).Elem() +} + +func (i DnsRecordSetArray) ToDnsRecordSetArrayOutput() DnsRecordSetArrayOutput { + return i.ToDnsRecordSetArrayOutputWithContext(context.Background()) +} + +func (i DnsRecordSetArray) ToDnsRecordSetArrayOutputWithContext(ctx context.Context) DnsRecordSetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsRecordSetArrayOutput) +} + +// DnsRecordSetMapInput is an input type that accepts DnsRecordSetMap and DnsRecordSetMapOutput values. +// You can construct a concrete instance of `DnsRecordSetMapInput` via: +// +// DnsRecordSetMap{ "key": DnsRecordSetArgs{...} } +type DnsRecordSetMapInput interface { + pulumi.Input + + ToDnsRecordSetMapOutput() DnsRecordSetMapOutput + ToDnsRecordSetMapOutputWithContext(context.Context) DnsRecordSetMapOutput +} + +type DnsRecordSetMap map[string]DnsRecordSetInput + +func (DnsRecordSetMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DnsRecordSet)(nil)).Elem() +} + +func (i DnsRecordSetMap) ToDnsRecordSetMapOutput() DnsRecordSetMapOutput { + return i.ToDnsRecordSetMapOutputWithContext(context.Background()) +} + +func (i DnsRecordSetMap) ToDnsRecordSetMapOutputWithContext(ctx context.Context) DnsRecordSetMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsRecordSetMapOutput) +} + +type DnsRecordSetOutput struct{ *pulumi.OutputState } + +func (DnsRecordSetOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DnsRecordSet)(nil)).Elem() +} + +func (o DnsRecordSetOutput) ToDnsRecordSetOutput() DnsRecordSetOutput { + return o +} + +func (o DnsRecordSetOutput) ToDnsRecordSetOutputWithContext(ctx context.Context) DnsRecordSetOutput { + return o +} + +// Specifies if the record set is active or not. Defaults to `true` +func (o DnsRecordSetOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.BoolOutput { return v.Active }).(pulumi.BoolOutput) +} + +// Comment. +func (o DnsRecordSetOutput) Comment() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.Comment }).(pulumi.StringOutput) +} + +// Error shows error in case create/update/delete failed. +func (o DnsRecordSetOutput) Error() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.Error }).(pulumi.StringOutput) +} + +// Fully qualified domain name (FQDN) of the record set. +func (o DnsRecordSetOutput) Fqdn() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.Fqdn }).(pulumi.StringOutput) +} + +// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` +func (o DnsRecordSetOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the dns record set is associated. +func (o DnsRecordSetOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The rr set id. +func (o DnsRecordSetOutput) RecordSetId() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.RecordSetId }).(pulumi.StringOutput) +} + +// Records. +func (o DnsRecordSetOutput) Records() pulumi.StringArrayOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringArrayOutput { return v.Records }).(pulumi.StringArrayOutput) +} + +// Record set state. +func (o DnsRecordSetOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.State }).(pulumi.StringOutput) +} + +// Time to live. E.g. 3600 +func (o DnsRecordSetOutput) Ttl() pulumi.IntOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.IntOutput { return v.Ttl }).(pulumi.IntOutput) +} + +// The record set type. E.g. `A` or `CNAME` +func (o DnsRecordSetOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput) +} + +// The zone ID to which is dns record set is associated. +func (o DnsRecordSetOutput) ZoneId() pulumi.StringOutput { + return o.ApplyT(func(v *DnsRecordSet) pulumi.StringOutput { return v.ZoneId }).(pulumi.StringOutput) +} + +type DnsRecordSetArrayOutput struct{ *pulumi.OutputState } + +func (DnsRecordSetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DnsRecordSet)(nil)).Elem() +} + +func (o DnsRecordSetArrayOutput) ToDnsRecordSetArrayOutput() DnsRecordSetArrayOutput { + return o +} + +func (o DnsRecordSetArrayOutput) ToDnsRecordSetArrayOutputWithContext(ctx context.Context) DnsRecordSetArrayOutput { + return o +} + +func (o DnsRecordSetArrayOutput) Index(i pulumi.IntInput) DnsRecordSetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DnsRecordSet { + return vs[0].([]*DnsRecordSet)[vs[1].(int)] + }).(DnsRecordSetOutput) +} + +type DnsRecordSetMapOutput struct{ *pulumi.OutputState } + +func (DnsRecordSetMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DnsRecordSet)(nil)).Elem() +} + +func (o DnsRecordSetMapOutput) ToDnsRecordSetMapOutput() DnsRecordSetMapOutput { + return o +} + +func (o DnsRecordSetMapOutput) ToDnsRecordSetMapOutputWithContext(ctx context.Context) DnsRecordSetMapOutput { + return o +} + +func (o DnsRecordSetMapOutput) MapIndex(k pulumi.StringInput) DnsRecordSetOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DnsRecordSet { + return vs[0].(map[string]*DnsRecordSet)[vs[1].(string)] + }).(DnsRecordSetOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DnsRecordSetInput)(nil)).Elem(), &DnsRecordSet{}) + pulumi.RegisterInputType(reflect.TypeOf((*DnsRecordSetArrayInput)(nil)).Elem(), DnsRecordSetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DnsRecordSetMapInput)(nil)).Elem(), DnsRecordSetMap{}) + pulumi.RegisterOutputType(DnsRecordSetOutput{}) + pulumi.RegisterOutputType(DnsRecordSetArrayOutput{}) + pulumi.RegisterOutputType(DnsRecordSetMapOutput{}) +} diff --git a/sdk/go/stackit/dnsZone.go b/sdk/go/stackit/dnsZone.go new file mode 100644 index 0000000..119a5f9 --- /dev/null +++ b/sdk/go/stackit/dnsZone.go @@ -0,0 +1,494 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// DNS Zone resource schema. +// +// ## Example Usage +type DnsZone struct { + pulumi.CustomResourceState + + // The access control list. E.g. `0.0.0.0/0,::/0` + Acl pulumi.StringOutput `pulumi:"acl"` + Active pulumi.BoolOutput `pulumi:"active"` + // A contact e-mail for the zone. + ContactEmail pulumi.StringOutput `pulumi:"contactEmail"` + // Default time to live. E.g. 3600. + DefaultTtl pulumi.IntOutput `pulumi:"defaultTtl"` + // Description of the zone. + Description pulumi.StringOutput `pulumi:"description"` + // The zone name. E.g. `example.com` + DnsName pulumi.StringOutput `pulumi:"dnsName"` + // Expire time. E.g. 1209600. + ExpireTime pulumi.IntOutput `pulumi:"expireTime"` + // Specifies, if the zone is a reverse zone or not. Defaults to `false` + IsReverseZone pulumi.BoolOutput `pulumi:"isReverseZone"` + // The user given name of the zone. + Name pulumi.StringOutput `pulumi:"name"` + // Negative caching. E.g. 60 + NegativeCache pulumi.IntOutput `pulumi:"negativeCache"` + // Primary name server for secondary zone. E.g. ["1.2.3.4"] + Primaries pulumi.StringArrayOutput `pulumi:"primaries"` + // Primary name server. FQDN. + PrimaryNameServer pulumi.StringOutput `pulumi:"primaryNameServer"` + // STACKIT project ID to which the dns zone is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Record count how many records are in the zone. + RecordCount pulumi.IntOutput `pulumi:"recordCount"` + // Refresh time. E.g. 3600 + RefreshTime pulumi.IntOutput `pulumi:"refreshTime"` + // Retry time. E.g. 600 + RetryTime pulumi.IntOutput `pulumi:"retryTime"` + // Serial number. E.g. `2022111400`. + SerialNumber pulumi.IntOutput `pulumi:"serialNumber"` + // Zone state. E.g. `CREATE_SUCCEEDED`. + State pulumi.StringOutput `pulumi:"state"` + // Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + Type pulumi.StringOutput `pulumi:"type"` + // Visibility of the zone. E.g. `public`. + Visibility pulumi.StringOutput `pulumi:"visibility"` + // The zone ID. + ZoneId pulumi.StringOutput `pulumi:"zoneId"` +} + +// NewDnsZone registers a new resource with the given unique name, arguments, and options. +func NewDnsZone(ctx *pulumi.Context, + name string, args *DnsZoneArgs, opts ...pulumi.ResourceOption) (*DnsZone, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.DnsName == nil { + return nil, errors.New("invalid value for required argument 'DnsName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource DnsZone + err := ctx.RegisterResource("stackit:index/dnsZone:DnsZone", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDnsZone gets an existing DnsZone 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 GetDnsZone(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DnsZoneState, opts ...pulumi.ResourceOption) (*DnsZone, error) { + var resource DnsZone + err := ctx.ReadResource("stackit:index/dnsZone:DnsZone", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DnsZone resources. +type dnsZoneState struct { + // The access control list. E.g. `0.0.0.0/0,::/0` + Acl *string `pulumi:"acl"` + Active *bool `pulumi:"active"` + // A contact e-mail for the zone. + ContactEmail *string `pulumi:"contactEmail"` + // Default time to live. E.g. 3600. + DefaultTtl *int `pulumi:"defaultTtl"` + // Description of the zone. + Description *string `pulumi:"description"` + // The zone name. E.g. `example.com` + DnsName *string `pulumi:"dnsName"` + // Expire time. E.g. 1209600. + ExpireTime *int `pulumi:"expireTime"` + // Specifies, if the zone is a reverse zone or not. Defaults to `false` + IsReverseZone *bool `pulumi:"isReverseZone"` + // The user given name of the zone. + Name *string `pulumi:"name"` + // Negative caching. E.g. 60 + NegativeCache *int `pulumi:"negativeCache"` + // Primary name server for secondary zone. E.g. ["1.2.3.4"] + Primaries []string `pulumi:"primaries"` + // Primary name server. FQDN. + PrimaryNameServer *string `pulumi:"primaryNameServer"` + // STACKIT project ID to which the dns zone is associated. + ProjectId *string `pulumi:"projectId"` + // Record count how many records are in the zone. + RecordCount *int `pulumi:"recordCount"` + // Refresh time. E.g. 3600 + RefreshTime *int `pulumi:"refreshTime"` + // Retry time. E.g. 600 + RetryTime *int `pulumi:"retryTime"` + // Serial number. E.g. `2022111400`. + SerialNumber *int `pulumi:"serialNumber"` + // Zone state. E.g. `CREATE_SUCCEEDED`. + State *string `pulumi:"state"` + // Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + Type *string `pulumi:"type"` + // Visibility of the zone. E.g. `public`. + Visibility *string `pulumi:"visibility"` + // The zone ID. + ZoneId *string `pulumi:"zoneId"` +} + +type DnsZoneState struct { + // The access control list. E.g. `0.0.0.0/0,::/0` + Acl pulumi.StringPtrInput + Active pulumi.BoolPtrInput + // A contact e-mail for the zone. + ContactEmail pulumi.StringPtrInput + // Default time to live. E.g. 3600. + DefaultTtl pulumi.IntPtrInput + // Description of the zone. + Description pulumi.StringPtrInput + // The zone name. E.g. `example.com` + DnsName pulumi.StringPtrInput + // Expire time. E.g. 1209600. + ExpireTime pulumi.IntPtrInput + // Specifies, if the zone is a reverse zone or not. Defaults to `false` + IsReverseZone pulumi.BoolPtrInput + // The user given name of the zone. + Name pulumi.StringPtrInput + // Negative caching. E.g. 60 + NegativeCache pulumi.IntPtrInput + // Primary name server for secondary zone. E.g. ["1.2.3.4"] + Primaries pulumi.StringArrayInput + // Primary name server. FQDN. + PrimaryNameServer pulumi.StringPtrInput + // STACKIT project ID to which the dns zone is associated. + ProjectId pulumi.StringPtrInput + // Record count how many records are in the zone. + RecordCount pulumi.IntPtrInput + // Refresh time. E.g. 3600 + RefreshTime pulumi.IntPtrInput + // Retry time. E.g. 600 + RetryTime pulumi.IntPtrInput + // Serial number. E.g. `2022111400`. + SerialNumber pulumi.IntPtrInput + // Zone state. E.g. `CREATE_SUCCEEDED`. + State pulumi.StringPtrInput + // Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + Type pulumi.StringPtrInput + // Visibility of the zone. E.g. `public`. + Visibility pulumi.StringPtrInput + // The zone ID. + ZoneId pulumi.StringPtrInput +} + +func (DnsZoneState) ElementType() reflect.Type { + return reflect.TypeOf((*dnsZoneState)(nil)).Elem() +} + +type dnsZoneArgs struct { + // The access control list. E.g. `0.0.0.0/0,::/0` + Acl *string `pulumi:"acl"` + Active *bool `pulumi:"active"` + // A contact e-mail for the zone. + ContactEmail *string `pulumi:"contactEmail"` + // Default time to live. E.g. 3600. + DefaultTtl *int `pulumi:"defaultTtl"` + // Description of the zone. + Description *string `pulumi:"description"` + // The zone name. E.g. `example.com` + DnsName string `pulumi:"dnsName"` + // Expire time. E.g. 1209600. + ExpireTime *int `pulumi:"expireTime"` + // Specifies, if the zone is a reverse zone or not. Defaults to `false` + IsReverseZone *bool `pulumi:"isReverseZone"` + // The user given name of the zone. + Name *string `pulumi:"name"` + // Negative caching. E.g. 60 + NegativeCache *int `pulumi:"negativeCache"` + // Primary name server for secondary zone. E.g. ["1.2.3.4"] + Primaries []string `pulumi:"primaries"` + // STACKIT project ID to which the dns zone is associated. + ProjectId string `pulumi:"projectId"` + // Refresh time. E.g. 3600 + RefreshTime *int `pulumi:"refreshTime"` + // Retry time. E.g. 600 + RetryTime *int `pulumi:"retryTime"` + // Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + Type *string `pulumi:"type"` +} + +// The set of arguments for constructing a DnsZone resource. +type DnsZoneArgs struct { + // The access control list. E.g. `0.0.0.0/0,::/0` + Acl pulumi.StringPtrInput + Active pulumi.BoolPtrInput + // A contact e-mail for the zone. + ContactEmail pulumi.StringPtrInput + // Default time to live. E.g. 3600. + DefaultTtl pulumi.IntPtrInput + // Description of the zone. + Description pulumi.StringPtrInput + // The zone name. E.g. `example.com` + DnsName pulumi.StringInput + // Expire time. E.g. 1209600. + ExpireTime pulumi.IntPtrInput + // Specifies, if the zone is a reverse zone or not. Defaults to `false` + IsReverseZone pulumi.BoolPtrInput + // The user given name of the zone. + Name pulumi.StringPtrInput + // Negative caching. E.g. 60 + NegativeCache pulumi.IntPtrInput + // Primary name server for secondary zone. E.g. ["1.2.3.4"] + Primaries pulumi.StringArrayInput + // STACKIT project ID to which the dns zone is associated. + ProjectId pulumi.StringInput + // Refresh time. E.g. 3600 + RefreshTime pulumi.IntPtrInput + // Retry time. E.g. 600 + RetryTime pulumi.IntPtrInput + // Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + Type pulumi.StringPtrInput +} + +func (DnsZoneArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dnsZoneArgs)(nil)).Elem() +} + +type DnsZoneInput interface { + pulumi.Input + + ToDnsZoneOutput() DnsZoneOutput + ToDnsZoneOutputWithContext(ctx context.Context) DnsZoneOutput +} + +func (*DnsZone) ElementType() reflect.Type { + return reflect.TypeOf((**DnsZone)(nil)).Elem() +} + +func (i *DnsZone) ToDnsZoneOutput() DnsZoneOutput { + return i.ToDnsZoneOutputWithContext(context.Background()) +} + +func (i *DnsZone) ToDnsZoneOutputWithContext(ctx context.Context) DnsZoneOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsZoneOutput) +} + +// DnsZoneArrayInput is an input type that accepts DnsZoneArray and DnsZoneArrayOutput values. +// You can construct a concrete instance of `DnsZoneArrayInput` via: +// +// DnsZoneArray{ DnsZoneArgs{...} } +type DnsZoneArrayInput interface { + pulumi.Input + + ToDnsZoneArrayOutput() DnsZoneArrayOutput + ToDnsZoneArrayOutputWithContext(context.Context) DnsZoneArrayOutput +} + +type DnsZoneArray []DnsZoneInput + +func (DnsZoneArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DnsZone)(nil)).Elem() +} + +func (i DnsZoneArray) ToDnsZoneArrayOutput() DnsZoneArrayOutput { + return i.ToDnsZoneArrayOutputWithContext(context.Background()) +} + +func (i DnsZoneArray) ToDnsZoneArrayOutputWithContext(ctx context.Context) DnsZoneArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsZoneArrayOutput) +} + +// DnsZoneMapInput is an input type that accepts DnsZoneMap and DnsZoneMapOutput values. +// You can construct a concrete instance of `DnsZoneMapInput` via: +// +// DnsZoneMap{ "key": DnsZoneArgs{...} } +type DnsZoneMapInput interface { + pulumi.Input + + ToDnsZoneMapOutput() DnsZoneMapOutput + ToDnsZoneMapOutputWithContext(context.Context) DnsZoneMapOutput +} + +type DnsZoneMap map[string]DnsZoneInput + +func (DnsZoneMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DnsZone)(nil)).Elem() +} + +func (i DnsZoneMap) ToDnsZoneMapOutput() DnsZoneMapOutput { + return i.ToDnsZoneMapOutputWithContext(context.Background()) +} + +func (i DnsZoneMap) ToDnsZoneMapOutputWithContext(ctx context.Context) DnsZoneMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DnsZoneMapOutput) +} + +type DnsZoneOutput struct{ *pulumi.OutputState } + +func (DnsZoneOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DnsZone)(nil)).Elem() +} + +func (o DnsZoneOutput) ToDnsZoneOutput() DnsZoneOutput { + return o +} + +func (o DnsZoneOutput) ToDnsZoneOutputWithContext(ctx context.Context) DnsZoneOutput { + return o +} + +// The access control list. E.g. `0.0.0.0/0,::/0` +func (o DnsZoneOutput) Acl() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.Acl }).(pulumi.StringOutput) +} + +func (o DnsZoneOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v *DnsZone) pulumi.BoolOutput { return v.Active }).(pulumi.BoolOutput) +} + +// A contact e-mail for the zone. +func (o DnsZoneOutput) ContactEmail() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.ContactEmail }).(pulumi.StringOutput) +} + +// Default time to live. E.g. 3600. +func (o DnsZoneOutput) DefaultTtl() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.DefaultTtl }).(pulumi.IntOutput) +} + +// Description of the zone. +func (o DnsZoneOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput) +} + +// The zone name. E.g. `example.com` +func (o DnsZoneOutput) DnsName() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.DnsName }).(pulumi.StringOutput) +} + +// Expire time. E.g. 1209600. +func (o DnsZoneOutput) ExpireTime() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.ExpireTime }).(pulumi.IntOutput) +} + +// Specifies, if the zone is a reverse zone or not. Defaults to `false` +func (o DnsZoneOutput) IsReverseZone() pulumi.BoolOutput { + return o.ApplyT(func(v *DnsZone) pulumi.BoolOutput { return v.IsReverseZone }).(pulumi.BoolOutput) +} + +// The user given name of the zone. +func (o DnsZoneOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Negative caching. E.g. 60 +func (o DnsZoneOutput) NegativeCache() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.NegativeCache }).(pulumi.IntOutput) +} + +// Primary name server for secondary zone. E.g. ["1.2.3.4"] +func (o DnsZoneOutput) Primaries() pulumi.StringArrayOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringArrayOutput { return v.Primaries }).(pulumi.StringArrayOutput) +} + +// Primary name server. FQDN. +func (o DnsZoneOutput) PrimaryNameServer() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.PrimaryNameServer }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the dns zone is associated. +func (o DnsZoneOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Record count how many records are in the zone. +func (o DnsZoneOutput) RecordCount() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.RecordCount }).(pulumi.IntOutput) +} + +// Refresh time. E.g. 3600 +func (o DnsZoneOutput) RefreshTime() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.RefreshTime }).(pulumi.IntOutput) +} + +// Retry time. E.g. 600 +func (o DnsZoneOutput) RetryTime() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.RetryTime }).(pulumi.IntOutput) +} + +// Serial number. E.g. `2022111400`. +func (o DnsZoneOutput) SerialNumber() pulumi.IntOutput { + return o.ApplyT(func(v *DnsZone) pulumi.IntOutput { return v.SerialNumber }).(pulumi.IntOutput) +} + +// Zone state. E.g. `CREATE_SUCCEEDED`. +func (o DnsZoneOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.State }).(pulumi.StringOutput) +} + +// Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. +func (o DnsZoneOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput) +} + +// Visibility of the zone. E.g. `public`. +func (o DnsZoneOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +// The zone ID. +func (o DnsZoneOutput) ZoneId() pulumi.StringOutput { + return o.ApplyT(func(v *DnsZone) pulumi.StringOutput { return v.ZoneId }).(pulumi.StringOutput) +} + +type DnsZoneArrayOutput struct{ *pulumi.OutputState } + +func (DnsZoneArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DnsZone)(nil)).Elem() +} + +func (o DnsZoneArrayOutput) ToDnsZoneArrayOutput() DnsZoneArrayOutput { + return o +} + +func (o DnsZoneArrayOutput) ToDnsZoneArrayOutputWithContext(ctx context.Context) DnsZoneArrayOutput { + return o +} + +func (o DnsZoneArrayOutput) Index(i pulumi.IntInput) DnsZoneOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DnsZone { + return vs[0].([]*DnsZone)[vs[1].(int)] + }).(DnsZoneOutput) +} + +type DnsZoneMapOutput struct{ *pulumi.OutputState } + +func (DnsZoneMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DnsZone)(nil)).Elem() +} + +func (o DnsZoneMapOutput) ToDnsZoneMapOutput() DnsZoneMapOutput { + return o +} + +func (o DnsZoneMapOutput) ToDnsZoneMapOutputWithContext(ctx context.Context) DnsZoneMapOutput { + return o +} + +func (o DnsZoneMapOutput) MapIndex(k pulumi.StringInput) DnsZoneOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DnsZone { + return vs[0].(map[string]*DnsZone)[vs[1].(string)] + }).(DnsZoneOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DnsZoneInput)(nil)).Elem(), &DnsZone{}) + pulumi.RegisterInputType(reflect.TypeOf((*DnsZoneArrayInput)(nil)).Elem(), DnsZoneArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DnsZoneMapInput)(nil)).Elem(), DnsZoneMap{}) + pulumi.RegisterOutputType(DnsZoneOutput{}) + pulumi.RegisterOutputType(DnsZoneArrayOutput{}) + pulumi.RegisterOutputType(DnsZoneMapOutput{}) +} diff --git a/sdk/go/stackit/doc.go b/sdk/go/stackit/doc.go new file mode 100644 index 0000000..136c327 --- /dev/null +++ b/sdk/go/stackit/doc.go @@ -0,0 +1,2 @@ +// A Pulumi package for creating and managing stackit resources. +package stackit diff --git a/sdk/go/stackit/getAffinityGroup.go b/sdk/go/stackit/getAffinityGroup.go new file mode 100644 index 0000000..c7a8ff7 --- /dev/null +++ b/sdk/go/stackit/getAffinityGroup.go @@ -0,0 +1,117 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Affinity Group schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupAffinityGroup(ctx *pulumi.Context, args *LookupAffinityGroupArgs, opts ...pulumi.InvokeOption) (*LookupAffinityGroupResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupAffinityGroupResult + err := ctx.Invoke("stackit:index/getAffinityGroup:getAffinityGroup", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getAffinityGroup. +type LookupAffinityGroupArgs struct { + // The affinity group ID. + AffinityGroupId string `pulumi:"affinityGroupId"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getAffinityGroup. +type LookupAffinityGroupResult struct { + // The affinity group ID. + AffinityGroupId string `pulumi:"affinityGroupId"` + Id string `pulumi:"id"` + // Affinity Group schema. Must have a `region` specified in the provider configuration. + Members []string `pulumi:"members"` + // The name of the affinity group. + Name string `pulumi:"name"` + // The policy of the affinity group. + Policy string `pulumi:"policy"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId string `pulumi:"projectId"` +} + +func LookupAffinityGroupOutput(ctx *pulumi.Context, args LookupAffinityGroupOutputArgs, opts ...pulumi.InvokeOption) LookupAffinityGroupResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupAffinityGroupResultOutput, error) { + args := v.(LookupAffinityGroupArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getAffinityGroup:getAffinityGroup", args, LookupAffinityGroupResultOutput{}, options).(LookupAffinityGroupResultOutput), nil + }).(LookupAffinityGroupResultOutput) +} + +// A collection of arguments for invoking getAffinityGroup. +type LookupAffinityGroupOutputArgs struct { + // The affinity group ID. + AffinityGroupId pulumi.StringInput `pulumi:"affinityGroupId"` + // STACKIT Project ID to which the affinity group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupAffinityGroupOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupAffinityGroupArgs)(nil)).Elem() +} + +// A collection of values returned by getAffinityGroup. +type LookupAffinityGroupResultOutput struct{ *pulumi.OutputState } + +func (LookupAffinityGroupResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupAffinityGroupResult)(nil)).Elem() +} + +func (o LookupAffinityGroupResultOutput) ToLookupAffinityGroupResultOutput() LookupAffinityGroupResultOutput { + return o +} + +func (o LookupAffinityGroupResultOutput) ToLookupAffinityGroupResultOutputWithContext(ctx context.Context) LookupAffinityGroupResultOutput { + return o +} + +// The affinity group ID. +func (o LookupAffinityGroupResultOutput) AffinityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) string { return v.AffinityGroupId }).(pulumi.StringOutput) +} + +func (o LookupAffinityGroupResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Affinity Group schema. Must have a `region` specified in the provider configuration. +func (o LookupAffinityGroupResultOutput) Members() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) []string { return v.Members }).(pulumi.StringArrayOutput) +} + +// The name of the affinity group. +func (o LookupAffinityGroupResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The policy of the affinity group. +func (o LookupAffinityGroupResultOutput) Policy() pulumi.StringOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) string { return v.Policy }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the affinity group is associated. +func (o LookupAffinityGroupResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupAffinityGroupResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupAffinityGroupResultOutput{}) +} diff --git a/sdk/go/stackit/getCdnCustomDomain.go b/sdk/go/stackit/getCdnCustomDomain.go new file mode 100644 index 0000000..c1cc6a9 --- /dev/null +++ b/sdk/go/stackit/getCdnCustomDomain.go @@ -0,0 +1,119 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// CDN distribution data source schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func LookupCdnCustomDomain(ctx *pulumi.Context, args *LookupCdnCustomDomainArgs, opts ...pulumi.InvokeOption) (*LookupCdnCustomDomainResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupCdnCustomDomainResult + err := ctx.Invoke("stackit:index/getCdnCustomDomain:getCdnCustomDomain", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getCdnCustomDomain. +type LookupCdnCustomDomainArgs struct { + // CDN distribution ID + DistributionId string `pulumi:"distributionId"` + Name string `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getCdnCustomDomain. +type LookupCdnCustomDomainResult struct { + // CDN distribution ID + DistributionId string `pulumi:"distributionId"` + // List of distribution errors + Errors []string `pulumi:"errors"` + Id string `pulumi:"id"` + Name string `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` + // Status of the distribution + Status string `pulumi:"status"` +} + +func LookupCdnCustomDomainOutput(ctx *pulumi.Context, args LookupCdnCustomDomainOutputArgs, opts ...pulumi.InvokeOption) LookupCdnCustomDomainResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupCdnCustomDomainResultOutput, error) { + args := v.(LookupCdnCustomDomainArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getCdnCustomDomain:getCdnCustomDomain", args, LookupCdnCustomDomainResultOutput{}, options).(LookupCdnCustomDomainResultOutput), nil + }).(LookupCdnCustomDomainResultOutput) +} + +// A collection of arguments for invoking getCdnCustomDomain. +type LookupCdnCustomDomainOutputArgs struct { + // CDN distribution ID + DistributionId pulumi.StringInput `pulumi:"distributionId"` + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupCdnCustomDomainOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupCdnCustomDomainArgs)(nil)).Elem() +} + +// A collection of values returned by getCdnCustomDomain. +type LookupCdnCustomDomainResultOutput struct{ *pulumi.OutputState } + +func (LookupCdnCustomDomainResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupCdnCustomDomainResult)(nil)).Elem() +} + +func (o LookupCdnCustomDomainResultOutput) ToLookupCdnCustomDomainResultOutput() LookupCdnCustomDomainResultOutput { + return o +} + +func (o LookupCdnCustomDomainResultOutput) ToLookupCdnCustomDomainResultOutputWithContext(ctx context.Context) LookupCdnCustomDomainResultOutput { + return o +} + +// CDN distribution ID +func (o LookupCdnCustomDomainResultOutput) DistributionId() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) string { return v.DistributionId }).(pulumi.StringOutput) +} + +// List of distribution errors +func (o LookupCdnCustomDomainResultOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) []string { return v.Errors }).(pulumi.StringArrayOutput) +} + +func (o LookupCdnCustomDomainResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupCdnCustomDomainResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID associated with the distribution +func (o LookupCdnCustomDomainResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Status of the distribution +func (o LookupCdnCustomDomainResultOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnCustomDomainResult) string { return v.Status }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupCdnCustomDomainResultOutput{}) +} diff --git a/sdk/go/stackit/getCdnDistribution.go b/sdk/go/stackit/getCdnDistribution.go new file mode 100644 index 0000000..1818ea3 --- /dev/null +++ b/sdk/go/stackit/getCdnDistribution.go @@ -0,0 +1,140 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// CDN distribution data source schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func LookupCdnDistribution(ctx *pulumi.Context, args *LookupCdnDistributionArgs, opts ...pulumi.InvokeOption) (*LookupCdnDistributionResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupCdnDistributionResult + err := ctx.Invoke("stackit:index/getCdnDistribution:getCdnDistribution", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getCdnDistribution. +type LookupCdnDistributionArgs struct { + // STACKIT project ID associated with the distribution + DistributionId string `pulumi:"distributionId"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getCdnDistribution. +type LookupCdnDistributionResult struct { + // The distribution configuration + Config GetCdnDistributionConfig `pulumi:"config"` + // Time when the distribution was created + CreatedAt string `pulumi:"createdAt"` + // STACKIT project ID associated with the distribution + DistributionId string `pulumi:"distributionId"` + // List of configured domains for the distribution + Domains []GetCdnDistributionDomain `pulumi:"domains"` + // List of distribution errors + Errors []string `pulumi:"errors"` + Id string `pulumi:"id"` + // STACKIT project ID associated with the distribution + ProjectId string `pulumi:"projectId"` + // Status of the distribution + Status string `pulumi:"status"` + // Time when the distribution was last updated + UpdatedAt string `pulumi:"updatedAt"` +} + +func LookupCdnDistributionOutput(ctx *pulumi.Context, args LookupCdnDistributionOutputArgs, opts ...pulumi.InvokeOption) LookupCdnDistributionResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupCdnDistributionResultOutput, error) { + args := v.(LookupCdnDistributionArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getCdnDistribution:getCdnDistribution", args, LookupCdnDistributionResultOutput{}, options).(LookupCdnDistributionResultOutput), nil + }).(LookupCdnDistributionResultOutput) +} + +// A collection of arguments for invoking getCdnDistribution. +type LookupCdnDistributionOutputArgs struct { + // STACKIT project ID associated with the distribution + DistributionId pulumi.StringInput `pulumi:"distributionId"` + // STACKIT project ID associated with the distribution + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupCdnDistributionOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupCdnDistributionArgs)(nil)).Elem() +} + +// A collection of values returned by getCdnDistribution. +type LookupCdnDistributionResultOutput struct{ *pulumi.OutputState } + +func (LookupCdnDistributionResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupCdnDistributionResult)(nil)).Elem() +} + +func (o LookupCdnDistributionResultOutput) ToLookupCdnDistributionResultOutput() LookupCdnDistributionResultOutput { + return o +} + +func (o LookupCdnDistributionResultOutput) ToLookupCdnDistributionResultOutputWithContext(ctx context.Context) LookupCdnDistributionResultOutput { + return o +} + +// The distribution configuration +func (o LookupCdnDistributionResultOutput) Config() GetCdnDistributionConfigOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) GetCdnDistributionConfig { return v.Config }).(GetCdnDistributionConfigOutput) +} + +// Time when the distribution was created +func (o LookupCdnDistributionResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// STACKIT project ID associated with the distribution +func (o LookupCdnDistributionResultOutput) DistributionId() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.DistributionId }).(pulumi.StringOutput) +} + +// List of configured domains for the distribution +func (o LookupCdnDistributionResultOutput) Domains() GetCdnDistributionDomainArrayOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) []GetCdnDistributionDomain { return v.Domains }).(GetCdnDistributionDomainArrayOutput) +} + +// List of distribution errors +func (o LookupCdnDistributionResultOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) []string { return v.Errors }).(pulumi.StringArrayOutput) +} + +func (o LookupCdnDistributionResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.Id }).(pulumi.StringOutput) +} + +// STACKIT project ID associated with the distribution +func (o LookupCdnDistributionResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Status of the distribution +func (o LookupCdnDistributionResultOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.Status }).(pulumi.StringOutput) +} + +// Time when the distribution was last updated +func (o LookupCdnDistributionResultOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupCdnDistributionResult) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupCdnDistributionResultOutput{}) +} diff --git a/sdk/go/stackit/getDnsRecordSet.go b/sdk/go/stackit/getDnsRecordSet.go new file mode 100644 index 0000000..d482fdf --- /dev/null +++ b/sdk/go/stackit/getDnsRecordSet.go @@ -0,0 +1,170 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// DNS Record Set Resource schema. +// +// ## Example Usage +func LookupDnsRecordSet(ctx *pulumi.Context, args *LookupDnsRecordSetArgs, opts ...pulumi.InvokeOption) (*LookupDnsRecordSetResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupDnsRecordSetResult + err := ctx.Invoke("stackit:index/getDnsRecordSet:getDnsRecordSet", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getDnsRecordSet. +type LookupDnsRecordSetArgs struct { + // STACKIT project ID to which the dns record set is associated. + ProjectId string `pulumi:"projectId"` + // The rr set id. + RecordSetId string `pulumi:"recordSetId"` + // The zone ID to which is dns record set is associated. + ZoneId string `pulumi:"zoneId"` +} + +// A collection of values returned by getDnsRecordSet. +type LookupDnsRecordSetResult struct { + // Specifies if the record set is active or not. + Active bool `pulumi:"active"` + // Comment. + Comment string `pulumi:"comment"` + // Error shows error in case create/update/delete failed. + Error string `pulumi:"error"` + // Fully qualified domain name (FQDN) of the record set. + Fqdn string `pulumi:"fqdn"` + Id string `pulumi:"id"` + // Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + Name string `pulumi:"name"` + // STACKIT project ID to which the dns record set is associated. + ProjectId string `pulumi:"projectId"` + // The rr set id. + RecordSetId string `pulumi:"recordSetId"` + // Records. + Records []string `pulumi:"records"` + // Record set state. + State string `pulumi:"state"` + // Time to live. E.g. 3600 + Ttl int `pulumi:"ttl"` + // The record set type. E.g. `A` or `CNAME` + Type string `pulumi:"type"` + // The zone ID to which is dns record set is associated. + ZoneId string `pulumi:"zoneId"` +} + +func LookupDnsRecordSetOutput(ctx *pulumi.Context, args LookupDnsRecordSetOutputArgs, opts ...pulumi.InvokeOption) LookupDnsRecordSetResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupDnsRecordSetResultOutput, error) { + args := v.(LookupDnsRecordSetArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getDnsRecordSet:getDnsRecordSet", args, LookupDnsRecordSetResultOutput{}, options).(LookupDnsRecordSetResultOutput), nil + }).(LookupDnsRecordSetResultOutput) +} + +// A collection of arguments for invoking getDnsRecordSet. +type LookupDnsRecordSetOutputArgs struct { + // STACKIT project ID to which the dns record set is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The rr set id. + RecordSetId pulumi.StringInput `pulumi:"recordSetId"` + // The zone ID to which is dns record set is associated. + ZoneId pulumi.StringInput `pulumi:"zoneId"` +} + +func (LookupDnsRecordSetOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupDnsRecordSetArgs)(nil)).Elem() +} + +// A collection of values returned by getDnsRecordSet. +type LookupDnsRecordSetResultOutput struct{ *pulumi.OutputState } + +func (LookupDnsRecordSetResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupDnsRecordSetResult)(nil)).Elem() +} + +func (o LookupDnsRecordSetResultOutput) ToLookupDnsRecordSetResultOutput() LookupDnsRecordSetResultOutput { + return o +} + +func (o LookupDnsRecordSetResultOutput) ToLookupDnsRecordSetResultOutputWithContext(ctx context.Context) LookupDnsRecordSetResultOutput { + return o +} + +// Specifies if the record set is active or not. +func (o LookupDnsRecordSetResultOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) bool { return v.Active }).(pulumi.BoolOutput) +} + +// Comment. +func (o LookupDnsRecordSetResultOutput) Comment() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Comment }).(pulumi.StringOutput) +} + +// Error shows error in case create/update/delete failed. +func (o LookupDnsRecordSetResultOutput) Error() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Error }).(pulumi.StringOutput) +} + +// Fully qualified domain name (FQDN) of the record set. +func (o LookupDnsRecordSetResultOutput) Fqdn() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Fqdn }).(pulumi.StringOutput) +} + +func (o LookupDnsRecordSetResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` +func (o LookupDnsRecordSetResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the dns record set is associated. +func (o LookupDnsRecordSetResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The rr set id. +func (o LookupDnsRecordSetResultOutput) RecordSetId() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.RecordSetId }).(pulumi.StringOutput) +} + +// Records. +func (o LookupDnsRecordSetResultOutput) Records() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) []string { return v.Records }).(pulumi.StringArrayOutput) +} + +// Record set state. +func (o LookupDnsRecordSetResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.State }).(pulumi.StringOutput) +} + +// Time to live. E.g. 3600 +func (o LookupDnsRecordSetResultOutput) Ttl() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) int { return v.Ttl }).(pulumi.IntOutput) +} + +// The record set type. E.g. `A` or `CNAME` +func (o LookupDnsRecordSetResultOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.Type }).(pulumi.StringOutput) +} + +// The zone ID to which is dns record set is associated. +func (o LookupDnsRecordSetResultOutput) ZoneId() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsRecordSetResult) string { return v.ZoneId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupDnsRecordSetResultOutput{}) +} diff --git a/sdk/go/stackit/getDnsZone.go b/sdk/go/stackit/getDnsZone.go new file mode 100644 index 0000000..688b606 --- /dev/null +++ b/sdk/go/stackit/getDnsZone.go @@ -0,0 +1,231 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// DNS Zone resource schema. +// +// ## Example Usage +func LookupDnsZone(ctx *pulumi.Context, args *LookupDnsZoneArgs, opts ...pulumi.InvokeOption) (*LookupDnsZoneResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupDnsZoneResult + err := ctx.Invoke("stackit:index/getDnsZone:getDnsZone", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getDnsZone. +type LookupDnsZoneArgs struct { + // The zone name. E.g. `example.com` + DnsName *string `pulumi:"dnsName"` + // STACKIT project ID to which the dns zone is associated. + ProjectId string `pulumi:"projectId"` + // The zone ID. + ZoneId *string `pulumi:"zoneId"` +} + +// A collection of values returned by getDnsZone. +type LookupDnsZoneResult struct { + // The access control list. + Acl string `pulumi:"acl"` + Active bool `pulumi:"active"` + // A contact e-mail for the zone. + ContactEmail string `pulumi:"contactEmail"` + // Default time to live. + DefaultTtl int `pulumi:"defaultTtl"` + // Description of the zone. + Description string `pulumi:"description"` + // The zone name. E.g. `example.com` + DnsName *string `pulumi:"dnsName"` + // Expire time. + ExpireTime int `pulumi:"expireTime"` + Id string `pulumi:"id"` + // Specifies, if the zone is a reverse zone or not. + IsReverseZone bool `pulumi:"isReverseZone"` + // The user given name of the zone. + Name string `pulumi:"name"` + // Negative caching. + NegativeCache int `pulumi:"negativeCache"` + // Primary name server for secondary zone. + Primaries []string `pulumi:"primaries"` + // Primary name server. FQDN. + PrimaryNameServer string `pulumi:"primaryNameServer"` + // STACKIT project ID to which the dns zone is associated. + ProjectId string `pulumi:"projectId"` + // Record count how many records are in the zone. + RecordCount int `pulumi:"recordCount"` + // Refresh time. + RefreshTime int `pulumi:"refreshTime"` + // Retry time. + RetryTime int `pulumi:"retryTime"` + // Serial number. + SerialNumber int `pulumi:"serialNumber"` + // Zone state. + State string `pulumi:"state"` + // Zone type. + Type string `pulumi:"type"` + // Visibility of the zone. + Visibility string `pulumi:"visibility"` + // The zone ID. + ZoneId *string `pulumi:"zoneId"` +} + +func LookupDnsZoneOutput(ctx *pulumi.Context, args LookupDnsZoneOutputArgs, opts ...pulumi.InvokeOption) LookupDnsZoneResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupDnsZoneResultOutput, error) { + args := v.(LookupDnsZoneArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getDnsZone:getDnsZone", args, LookupDnsZoneResultOutput{}, options).(LookupDnsZoneResultOutput), nil + }).(LookupDnsZoneResultOutput) +} + +// A collection of arguments for invoking getDnsZone. +type LookupDnsZoneOutputArgs struct { + // The zone name. E.g. `example.com` + DnsName pulumi.StringPtrInput `pulumi:"dnsName"` + // STACKIT project ID to which the dns zone is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The zone ID. + ZoneId pulumi.StringPtrInput `pulumi:"zoneId"` +} + +func (LookupDnsZoneOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupDnsZoneArgs)(nil)).Elem() +} + +// A collection of values returned by getDnsZone. +type LookupDnsZoneResultOutput struct{ *pulumi.OutputState } + +func (LookupDnsZoneResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupDnsZoneResult)(nil)).Elem() +} + +func (o LookupDnsZoneResultOutput) ToLookupDnsZoneResultOutput() LookupDnsZoneResultOutput { + return o +} + +func (o LookupDnsZoneResultOutput) ToLookupDnsZoneResultOutputWithContext(ctx context.Context) LookupDnsZoneResultOutput { + return o +} + +// The access control list. +func (o LookupDnsZoneResultOutput) Acl() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Acl }).(pulumi.StringOutput) +} + +func (o LookupDnsZoneResultOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v LookupDnsZoneResult) bool { return v.Active }).(pulumi.BoolOutput) +} + +// A contact e-mail for the zone. +func (o LookupDnsZoneResultOutput) ContactEmail() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.ContactEmail }).(pulumi.StringOutput) +} + +// Default time to live. +func (o LookupDnsZoneResultOutput) DefaultTtl() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.DefaultTtl }).(pulumi.IntOutput) +} + +// Description of the zone. +func (o LookupDnsZoneResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The zone name. E.g. `example.com` +func (o LookupDnsZoneResultOutput) DnsName() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupDnsZoneResult) *string { return v.DnsName }).(pulumi.StringPtrOutput) +} + +// Expire time. +func (o LookupDnsZoneResultOutput) ExpireTime() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.ExpireTime }).(pulumi.IntOutput) +} + +func (o LookupDnsZoneResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Specifies, if the zone is a reverse zone or not. +func (o LookupDnsZoneResultOutput) IsReverseZone() pulumi.BoolOutput { + return o.ApplyT(func(v LookupDnsZoneResult) bool { return v.IsReverseZone }).(pulumi.BoolOutput) +} + +// The user given name of the zone. +func (o LookupDnsZoneResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Negative caching. +func (o LookupDnsZoneResultOutput) NegativeCache() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.NegativeCache }).(pulumi.IntOutput) +} + +// Primary name server for secondary zone. +func (o LookupDnsZoneResultOutput) Primaries() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupDnsZoneResult) []string { return v.Primaries }).(pulumi.StringArrayOutput) +} + +// Primary name server. FQDN. +func (o LookupDnsZoneResultOutput) PrimaryNameServer() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.PrimaryNameServer }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the dns zone is associated. +func (o LookupDnsZoneResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Record count how many records are in the zone. +func (o LookupDnsZoneResultOutput) RecordCount() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.RecordCount }).(pulumi.IntOutput) +} + +// Refresh time. +func (o LookupDnsZoneResultOutput) RefreshTime() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.RefreshTime }).(pulumi.IntOutput) +} + +// Retry time. +func (o LookupDnsZoneResultOutput) RetryTime() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.RetryTime }).(pulumi.IntOutput) +} + +// Serial number. +func (o LookupDnsZoneResultOutput) SerialNumber() pulumi.IntOutput { + return o.ApplyT(func(v LookupDnsZoneResult) int { return v.SerialNumber }).(pulumi.IntOutput) +} + +// Zone state. +func (o LookupDnsZoneResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.State }).(pulumi.StringOutput) +} + +// Zone type. +func (o LookupDnsZoneResultOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Type }).(pulumi.StringOutput) +} + +// Visibility of the zone. +func (o LookupDnsZoneResultOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v LookupDnsZoneResult) string { return v.Visibility }).(pulumi.StringOutput) +} + +// The zone ID. +func (o LookupDnsZoneResultOutput) ZoneId() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupDnsZoneResult) *string { return v.ZoneId }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupDnsZoneResultOutput{}) +} diff --git a/sdk/go/stackit/getGit.go b/sdk/go/stackit/getGit.go new file mode 100644 index 0000000..95cfcb4 --- /dev/null +++ b/sdk/go/stackit/getGit.go @@ -0,0 +1,119 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Git Instance datasource schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func LookupGit(ctx *pulumi.Context, args *LookupGitArgs, opts ...pulumi.InvokeOption) (*LookupGitResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupGitResult + err := ctx.Invoke("stackit:index/getGit:getGit", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getGit. +type LookupGitArgs struct { + // ID linked to the git instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the git instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getGit. +type LookupGitResult struct { + Id string `pulumi:"id"` + // ID linked to the git instance. + InstanceId string `pulumi:"instanceId"` + // Unique name linked to the git instance. + Name string `pulumi:"name"` + // STACKIT project ID to which the git instance is associated. + ProjectId string `pulumi:"projectId"` + // Url linked to the git instance. + Url string `pulumi:"url"` + // Version linked to the git instance. + Version string `pulumi:"version"` +} + +func LookupGitOutput(ctx *pulumi.Context, args LookupGitOutputArgs, opts ...pulumi.InvokeOption) LookupGitResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupGitResultOutput, error) { + args := v.(LookupGitArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getGit:getGit", args, LookupGitResultOutput{}, options).(LookupGitResultOutput), nil + }).(LookupGitResultOutput) +} + +// A collection of arguments for invoking getGit. +type LookupGitOutputArgs struct { + // ID linked to the git instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the git instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupGitOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupGitArgs)(nil)).Elem() +} + +// A collection of values returned by getGit. +type LookupGitResultOutput struct{ *pulumi.OutputState } + +func (LookupGitResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupGitResult)(nil)).Elem() +} + +func (o LookupGitResultOutput) ToLookupGitResultOutput() LookupGitResultOutput { + return o +} + +func (o LookupGitResultOutput) ToLookupGitResultOutputWithContext(ctx context.Context) LookupGitResultOutput { + return o +} + +func (o LookupGitResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID linked to the git instance. +func (o LookupGitResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Unique name linked to the git instance. +func (o LookupGitResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the git instance is associated. +func (o LookupGitResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Url linked to the git instance. +func (o LookupGitResultOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.Url }).(pulumi.StringOutput) +} + +// Version linked to the git instance. +func (o LookupGitResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupGitResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupGitResultOutput{}) +} diff --git a/sdk/go/stackit/getImage.go b/sdk/go/stackit/getImage.go new file mode 100644 index 0000000..13a3df6 --- /dev/null +++ b/sdk/go/stackit/getImage.go @@ -0,0 +1,159 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Image datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupImage(ctx *pulumi.Context, args *LookupImageArgs, opts ...pulumi.InvokeOption) (*LookupImageResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupImageResult + err := ctx.Invoke("stackit:index/getImage:getImage", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getImage. +type LookupImageArgs struct { + // The image ID. + ImageId string `pulumi:"imageId"` + // STACKIT project ID to which the image is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getImage. +type LookupImageResult struct { + // Representation of an image checksum. + Checksum GetImageChecksum `pulumi:"checksum"` + // Properties to set hardware and scheduling settings for an image. + Config GetImageConfig `pulumi:"config"` + // The disk format of the image. + DiskFormat string `pulumi:"diskFormat"` + Id string `pulumi:"id"` + // The image ID. + ImageId string `pulumi:"imageId"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The minimum disk size of the image in GB. + MinDiskSize int `pulumi:"minDiskSize"` + // The minimum RAM of the image in MB. + MinRam int `pulumi:"minRam"` + // The name of the image. + Name string `pulumi:"name"` + // STACKIT project ID to which the image is associated. + ProjectId string `pulumi:"projectId"` + // Whether the image is protected. + Protected bool `pulumi:"protected"` + // The scope of the image. + Scope string `pulumi:"scope"` +} + +func LookupImageOutput(ctx *pulumi.Context, args LookupImageOutputArgs, opts ...pulumi.InvokeOption) LookupImageResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupImageResultOutput, error) { + args := v.(LookupImageArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getImage:getImage", args, LookupImageResultOutput{}, options).(LookupImageResultOutput), nil + }).(LookupImageResultOutput) +} + +// A collection of arguments for invoking getImage. +type LookupImageOutputArgs struct { + // The image ID. + ImageId pulumi.StringInput `pulumi:"imageId"` + // STACKIT project ID to which the image is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupImageOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupImageArgs)(nil)).Elem() +} + +// A collection of values returned by getImage. +type LookupImageResultOutput struct{ *pulumi.OutputState } + +func (LookupImageResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupImageResult)(nil)).Elem() +} + +func (o LookupImageResultOutput) ToLookupImageResultOutput() LookupImageResultOutput { + return o +} + +func (o LookupImageResultOutput) ToLookupImageResultOutputWithContext(ctx context.Context) LookupImageResultOutput { + return o +} + +// Representation of an image checksum. +func (o LookupImageResultOutput) Checksum() GetImageChecksumOutput { + return o.ApplyT(func(v LookupImageResult) GetImageChecksum { return v.Checksum }).(GetImageChecksumOutput) +} + +// Properties to set hardware and scheduling settings for an image. +func (o LookupImageResultOutput) Config() GetImageConfigOutput { + return o.ApplyT(func(v LookupImageResult) GetImageConfig { return v.Config }).(GetImageConfigOutput) +} + +// The disk format of the image. +func (o LookupImageResultOutput) DiskFormat() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.DiskFormat }).(pulumi.StringOutput) +} + +func (o LookupImageResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The image ID. +func (o LookupImageResultOutput) ImageId() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.ImageId }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupImageResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupImageResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The minimum disk size of the image in GB. +func (o LookupImageResultOutput) MinDiskSize() pulumi.IntOutput { + return o.ApplyT(func(v LookupImageResult) int { return v.MinDiskSize }).(pulumi.IntOutput) +} + +// The minimum RAM of the image in MB. +func (o LookupImageResultOutput) MinRam() pulumi.IntOutput { + return o.ApplyT(func(v LookupImageResult) int { return v.MinRam }).(pulumi.IntOutput) +} + +// The name of the image. +func (o LookupImageResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the image is associated. +func (o LookupImageResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Whether the image is protected. +func (o LookupImageResultOutput) Protected() pulumi.BoolOutput { + return o.ApplyT(func(v LookupImageResult) bool { return v.Protected }).(pulumi.BoolOutput) +} + +// The scope of the image. +func (o LookupImageResultOutput) Scope() pulumi.StringOutput { + return o.ApplyT(func(v LookupImageResult) string { return v.Scope }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupImageResultOutput{}) +} diff --git a/sdk/go/stackit/getKeyPair.go b/sdk/go/stackit/getKeyPair.go new file mode 100644 index 0000000..2919008 --- /dev/null +++ b/sdk/go/stackit/getKeyPair.go @@ -0,0 +1,106 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Key pair resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupKeyPair(ctx *pulumi.Context, args *LookupKeyPairArgs, opts ...pulumi.InvokeOption) (*LookupKeyPairResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupKeyPairResult + err := ctx.Invoke("stackit:index/getKeyPair:getKeyPair", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getKeyPair. +type LookupKeyPairArgs struct { + // The name of the SSH key pair. + Name string `pulumi:"name"` +} + +// A collection of values returned by getKeyPair. +type LookupKeyPairResult struct { + // The fingerprint of the public SSH key. + Fingerprint string `pulumi:"fingerprint"` + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container. + Labels map[string]string `pulumi:"labels"` + // The name of the SSH key pair. + Name string `pulumi:"name"` + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey string `pulumi:"publicKey"` +} + +func LookupKeyPairOutput(ctx *pulumi.Context, args LookupKeyPairOutputArgs, opts ...pulumi.InvokeOption) LookupKeyPairResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupKeyPairResultOutput, error) { + args := v.(LookupKeyPairArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getKeyPair:getKeyPair", args, LookupKeyPairResultOutput{}, options).(LookupKeyPairResultOutput), nil + }).(LookupKeyPairResultOutput) +} + +// A collection of arguments for invoking getKeyPair. +type LookupKeyPairOutputArgs struct { + // The name of the SSH key pair. + Name pulumi.StringInput `pulumi:"name"` +} + +func (LookupKeyPairOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupKeyPairArgs)(nil)).Elem() +} + +// A collection of values returned by getKeyPair. +type LookupKeyPairResultOutput struct{ *pulumi.OutputState } + +func (LookupKeyPairResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupKeyPairResult)(nil)).Elem() +} + +func (o LookupKeyPairResultOutput) ToLookupKeyPairResultOutput() LookupKeyPairResultOutput { + return o +} + +func (o LookupKeyPairResultOutput) ToLookupKeyPairResultOutputWithContext(ctx context.Context) LookupKeyPairResultOutput { + return o +} + +// The fingerprint of the public SSH key. +func (o LookupKeyPairResultOutput) Fingerprint() pulumi.StringOutput { + return o.ApplyT(func(v LookupKeyPairResult) string { return v.Fingerprint }).(pulumi.StringOutput) +} + +func (o LookupKeyPairResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupKeyPairResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container. +func (o LookupKeyPairResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupKeyPairResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the SSH key pair. +func (o LookupKeyPairResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupKeyPairResult) string { return v.Name }).(pulumi.StringOutput) +} + +// A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. +func (o LookupKeyPairResultOutput) PublicKey() pulumi.StringOutput { + return o.ApplyT(func(v LookupKeyPairResult) string { return v.PublicKey }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupKeyPairResultOutput{}) +} diff --git a/sdk/go/stackit/getLoadbalancer.go b/sdk/go/stackit/getLoadbalancer.go new file mode 100644 index 0000000..0883e2d --- /dev/null +++ b/sdk/go/stackit/getLoadbalancer.go @@ -0,0 +1,149 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Load Balancer data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupLoadbalancer(ctx *pulumi.Context, args *LookupLoadbalancerArgs, opts ...pulumi.InvokeOption) (*LookupLoadbalancerResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupLoadbalancerResult + err := ctx.Invoke("stackit:index/getLoadbalancer:getLoadbalancer", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getLoadbalancer. +type LookupLoadbalancerArgs struct { + // Load balancer name. + Name string `pulumi:"name"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getLoadbalancer. +type LookupLoadbalancerResult struct { + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress string `pulumi:"externalAddress"` + Id string `pulumi:"id"` + // List of all listeners which will accept traffic. Limited to 20. + Listeners []GetLoadbalancerListener `pulumi:"listeners"` + // Load balancer name. + Name string `pulumi:"name"` + // List of networks that listeners and targets reside in. + Networks []GetLoadbalancerNetwork `pulumi:"networks"` + // Defines any optional functionality you want to have enabled on your load balancer. + Options GetLoadbalancerOptions `pulumi:"options"` + // Transient private Load Balancer IP address. It can change any time. + PrivateAddress string `pulumi:"privateAddress"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools []GetLoadbalancerTargetPool `pulumi:"targetPools"` +} + +func LookupLoadbalancerOutput(ctx *pulumi.Context, args LookupLoadbalancerOutputArgs, opts ...pulumi.InvokeOption) LookupLoadbalancerResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupLoadbalancerResultOutput, error) { + args := v.(LookupLoadbalancerArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getLoadbalancer:getLoadbalancer", args, LookupLoadbalancerResultOutput{}, options).(LookupLoadbalancerResultOutput), nil + }).(LookupLoadbalancerResultOutput) +} + +// A collection of arguments for invoking getLoadbalancer. +type LookupLoadbalancerOutputArgs struct { + // Load balancer name. + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupLoadbalancerOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLoadbalancerArgs)(nil)).Elem() +} + +// A collection of values returned by getLoadbalancer. +type LookupLoadbalancerResultOutput struct{ *pulumi.OutputState } + +func (LookupLoadbalancerResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLoadbalancerResult)(nil)).Elem() +} + +func (o LookupLoadbalancerResultOutput) ToLookupLoadbalancerResultOutput() LookupLoadbalancerResultOutput { + return o +} + +func (o LookupLoadbalancerResultOutput) ToLookupLoadbalancerResultOutputWithContext(ctx context.Context) LookupLoadbalancerResultOutput { + return o +} + +// External Load Balancer IP address where this Load Balancer is exposed. +func (o LookupLoadbalancerResultOutput) ExternalAddress() pulumi.StringOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) string { return v.ExternalAddress }).(pulumi.StringOutput) +} + +func (o LookupLoadbalancerResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) string { return v.Id }).(pulumi.StringOutput) +} + +// List of all listeners which will accept traffic. Limited to 20. +func (o LookupLoadbalancerResultOutput) Listeners() GetLoadbalancerListenerArrayOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) []GetLoadbalancerListener { return v.Listeners }).(GetLoadbalancerListenerArrayOutput) +} + +// Load balancer name. +func (o LookupLoadbalancerResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) string { return v.Name }).(pulumi.StringOutput) +} + +// List of networks that listeners and targets reside in. +func (o LookupLoadbalancerResultOutput) Networks() GetLoadbalancerNetworkArrayOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) []GetLoadbalancerNetwork { return v.Networks }).(GetLoadbalancerNetworkArrayOutput) +} + +// Defines any optional functionality you want to have enabled on your load balancer. +func (o LookupLoadbalancerResultOutput) Options() GetLoadbalancerOptionsOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) GetLoadbalancerOptions { return v.Options }).(GetLoadbalancerOptionsOutput) +} + +// Transient private Load Balancer IP address. It can change any time. +func (o LookupLoadbalancerResultOutput) PrivateAddress() pulumi.StringOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) string { return v.PrivateAddress }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the Load Balancer is associated. +func (o LookupLoadbalancerResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupLoadbalancerResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// List of all target pools which will be used in the Load Balancer. Limited to 20. +func (o LookupLoadbalancerResultOutput) TargetPools() GetLoadbalancerTargetPoolArrayOutput { + return o.ApplyT(func(v LookupLoadbalancerResult) []GetLoadbalancerTargetPool { return v.TargetPools }).(GetLoadbalancerTargetPoolArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupLoadbalancerResultOutput{}) +} diff --git a/sdk/go/stackit/getLogmeCredential.go b/sdk/go/stackit/getLogmeCredential.go new file mode 100644 index 0000000..65d0129 --- /dev/null +++ b/sdk/go/stackit/getLogmeCredential.go @@ -0,0 +1,132 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// LogMe credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupLogmeCredential(ctx *pulumi.Context, args *LookupLogmeCredentialArgs, opts ...pulumi.InvokeOption) (*LookupLogmeCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupLogmeCredentialResult + err := ctx.Invoke("stackit:index/getLogmeCredential:getLogmeCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getLogmeCredential. +type LookupLogmeCredentialArgs struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + // ID of the LogMe instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getLogmeCredential. +type LookupLogmeCredentialResult struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + Host string `pulumi:"host"` + Id string `pulumi:"id"` + // ID of the LogMe instance. + InstanceId string `pulumi:"instanceId"` + Password string `pulumi:"password"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Uri string `pulumi:"uri"` + Username string `pulumi:"username"` +} + +func LookupLogmeCredentialOutput(ctx *pulumi.Context, args LookupLogmeCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupLogmeCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupLogmeCredentialResultOutput, error) { + args := v.(LookupLogmeCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getLogmeCredential:getLogmeCredential", args, LookupLogmeCredentialResultOutput{}, options).(LookupLogmeCredentialResultOutput), nil + }).(LookupLogmeCredentialResultOutput) +} + +// A collection of arguments for invoking getLogmeCredential. +type LookupLogmeCredentialOutputArgs struct { + // The credential's ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // ID of the LogMe instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupLogmeCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLogmeCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getLogmeCredential. +type LookupLogmeCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupLogmeCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLogmeCredentialResult)(nil)).Elem() +} + +func (o LookupLogmeCredentialResultOutput) ToLookupLogmeCredentialResultOutput() LookupLogmeCredentialResultOutput { + return o +} + +func (o LookupLogmeCredentialResultOutput) ToLookupLogmeCredentialResultOutputWithContext(ctx context.Context) LookupLogmeCredentialResultOutput { + return o +} + +// The credential's ID. +func (o LookupLogmeCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the LogMe instance. +func (o LookupLogmeCredentialResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.Password }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupLogmeCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.Uri }).(pulumi.StringOutput) +} + +func (o LookupLogmeCredentialResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeCredentialResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupLogmeCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getLogmeInstance.go b/sdk/go/stackit/getLogmeInstance.go new file mode 100644 index 0000000..44a6912 --- /dev/null +++ b/sdk/go/stackit/getLogmeInstance.go @@ -0,0 +1,154 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// LogMe instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupLogmeInstance(ctx *pulumi.Context, args *LookupLogmeInstanceArgs, opts ...pulumi.InvokeOption) (*LookupLogmeInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupLogmeInstanceResult + err := ctx.Invoke("stackit:index/getLogmeInstance:getLogmeInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getLogmeInstance. +type LookupLogmeInstanceArgs struct { + // ID of the LogMe instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getLogmeInstance. +type LookupLogmeInstanceResult struct { + CfGuid string `pulumi:"cfGuid"` + CfOrganizationGuid string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid string `pulumi:"cfSpaceGuid"` + DashboardUrl string `pulumi:"dashboardUrl"` + Id string `pulumi:"id"` + ImageUrl string `pulumi:"imageUrl"` + // ID of the LogMe instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + Parameters GetLogmeInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId string `pulumi:"planId"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +func LookupLogmeInstanceOutput(ctx *pulumi.Context, args LookupLogmeInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupLogmeInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupLogmeInstanceResultOutput, error) { + args := v.(LookupLogmeInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getLogmeInstance:getLogmeInstance", args, LookupLogmeInstanceResultOutput{}, options).(LookupLogmeInstanceResultOutput), nil + }).(LookupLogmeInstanceResultOutput) +} + +// A collection of arguments for invoking getLogmeInstance. +type LookupLogmeInstanceOutputArgs struct { + // ID of the LogMe instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupLogmeInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLogmeInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getLogmeInstance. +type LookupLogmeInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupLogmeInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupLogmeInstanceResult)(nil)).Elem() +} + +func (o LookupLogmeInstanceResultOutput) ToLookupLogmeInstanceResultOutput() LookupLogmeInstanceResultOutput { + return o +} + +func (o LookupLogmeInstanceResultOutput) ToLookupLogmeInstanceResultOutputWithContext(ctx context.Context) LookupLogmeInstanceResultOutput { + return o +} + +func (o LookupLogmeInstanceResultOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the LogMe instance. +func (o LookupLogmeInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupLogmeInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupLogmeInstanceResultOutput) Parameters() GetLogmeInstanceParametersOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) GetLogmeInstanceParameters { return v.Parameters }).(GetLogmeInstanceParametersOutput) +} + +// The selected plan ID. +func (o LookupLogmeInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LookupLogmeInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupLogmeInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LookupLogmeInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupLogmeInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupLogmeInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getMariadbCredential.go b/sdk/go/stackit/getMariadbCredential.go new file mode 100644 index 0000000..ef042c9 --- /dev/null +++ b/sdk/go/stackit/getMariadbCredential.go @@ -0,0 +1,142 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MariaDB credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupMariadbCredential(ctx *pulumi.Context, args *LookupMariadbCredentialArgs, opts ...pulumi.InvokeOption) (*LookupMariadbCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupMariadbCredentialResult + err := ctx.Invoke("stackit:index/getMariadbCredential:getMariadbCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getMariadbCredential. +type LookupMariadbCredentialArgs struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + // ID of the MariaDB instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getMariadbCredential. +type LookupMariadbCredentialResult struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + Host string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + Id string `pulumi:"id"` + // ID of the MariaDB instance. + InstanceId string `pulumi:"instanceId"` + Name string `pulumi:"name"` + Password string `pulumi:"password"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Uri string `pulumi:"uri"` + Username string `pulumi:"username"` +} + +func LookupMariadbCredentialOutput(ctx *pulumi.Context, args LookupMariadbCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupMariadbCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupMariadbCredentialResultOutput, error) { + args := v.(LookupMariadbCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getMariadbCredential:getMariadbCredential", args, LookupMariadbCredentialResultOutput{}, options).(LookupMariadbCredentialResultOutput), nil + }).(LookupMariadbCredentialResultOutput) +} + +// A collection of arguments for invoking getMariadbCredential. +type LookupMariadbCredentialOutputArgs struct { + // The credential's ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // ID of the MariaDB instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupMariadbCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMariadbCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getMariadbCredential. +type LookupMariadbCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupMariadbCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMariadbCredentialResult)(nil)).Elem() +} + +func (o LookupMariadbCredentialResultOutput) ToLookupMariadbCredentialResultOutput() LookupMariadbCredentialResultOutput { + return o +} + +func (o LookupMariadbCredentialResultOutput) ToLookupMariadbCredentialResultOutputWithContext(ctx context.Context) LookupMariadbCredentialResultOutput { + return o +} + +// The credential's ID. +func (o LookupMariadbCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) []string { return v.Hosts }).(pulumi.StringArrayOutput) +} + +func (o LookupMariadbCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the MariaDB instance. +func (o LookupMariadbCredentialResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Password }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupMariadbCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Uri }).(pulumi.StringOutput) +} + +func (o LookupMariadbCredentialResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbCredentialResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupMariadbCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getMariadbInstance.go b/sdk/go/stackit/getMariadbInstance.go new file mode 100644 index 0000000..f0597c4 --- /dev/null +++ b/sdk/go/stackit/getMariadbInstance.go @@ -0,0 +1,154 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MariaDB instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupMariadbInstance(ctx *pulumi.Context, args *LookupMariadbInstanceArgs, opts ...pulumi.InvokeOption) (*LookupMariadbInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupMariadbInstanceResult + err := ctx.Invoke("stackit:index/getMariadbInstance:getMariadbInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getMariadbInstance. +type LookupMariadbInstanceArgs struct { + // ID of the MariaDB instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getMariadbInstance. +type LookupMariadbInstanceResult struct { + CfGuid string `pulumi:"cfGuid"` + CfOrganizationGuid string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid string `pulumi:"cfSpaceGuid"` + DashboardUrl string `pulumi:"dashboardUrl"` + Id string `pulumi:"id"` + ImageUrl string `pulumi:"imageUrl"` + // ID of the MariaDB instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + Parameters GetMariadbInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId string `pulumi:"planId"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +func LookupMariadbInstanceOutput(ctx *pulumi.Context, args LookupMariadbInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupMariadbInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupMariadbInstanceResultOutput, error) { + args := v.(LookupMariadbInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getMariadbInstance:getMariadbInstance", args, LookupMariadbInstanceResultOutput{}, options).(LookupMariadbInstanceResultOutput), nil + }).(LookupMariadbInstanceResultOutput) +} + +// A collection of arguments for invoking getMariadbInstance. +type LookupMariadbInstanceOutputArgs struct { + // ID of the MariaDB instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupMariadbInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMariadbInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getMariadbInstance. +type LookupMariadbInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupMariadbInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMariadbInstanceResult)(nil)).Elem() +} + +func (o LookupMariadbInstanceResultOutput) ToLookupMariadbInstanceResultOutput() LookupMariadbInstanceResultOutput { + return o +} + +func (o LookupMariadbInstanceResultOutput) ToLookupMariadbInstanceResultOutputWithContext(ctx context.Context) LookupMariadbInstanceResultOutput { + return o +} + +func (o LookupMariadbInstanceResultOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the MariaDB instance. +func (o LookupMariadbInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupMariadbInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupMariadbInstanceResultOutput) Parameters() GetMariadbInstanceParametersOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) GetMariadbInstanceParameters { return v.Parameters }).(GetMariadbInstanceParametersOutput) +} + +// The selected plan ID. +func (o LookupMariadbInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LookupMariadbInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupMariadbInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LookupMariadbInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupMariadbInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupMariadbInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getMongodbflexInstance.go b/sdk/go/stackit/getMongodbflexInstance.go new file mode 100644 index 0000000..7093bdf --- /dev/null +++ b/sdk/go/stackit/getMongodbflexInstance.go @@ -0,0 +1,144 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupMongodbflexInstance(ctx *pulumi.Context, args *LookupMongodbflexInstanceArgs, opts ...pulumi.InvokeOption) (*LookupMongodbflexInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupMongodbflexInstanceResult + err := ctx.Invoke("stackit:index/getMongodbflexInstance:getMongodbflexInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getMongodbflexInstance. +type LookupMongodbflexInstanceArgs struct { + // ID of the MongoDB Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getMongodbflexInstance. +type LookupMongodbflexInstanceResult struct { + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule string `pulumi:"backupSchedule"` + Flavor GetMongodbflexInstanceFlavor `pulumi:"flavor"` + Id string `pulumi:"id"` + // ID of the MongoDB Flex instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + // Custom parameters for the MongoDB Flex instance. + Options GetMongodbflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Replicas int `pulumi:"replicas"` + Storage GetMongodbflexInstanceStorage `pulumi:"storage"` + Version string `pulumi:"version"` +} + +func LookupMongodbflexInstanceOutput(ctx *pulumi.Context, args LookupMongodbflexInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupMongodbflexInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupMongodbflexInstanceResultOutput, error) { + args := v.(LookupMongodbflexInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getMongodbflexInstance:getMongodbflexInstance", args, LookupMongodbflexInstanceResultOutput{}, options).(LookupMongodbflexInstanceResultOutput), nil + }).(LookupMongodbflexInstanceResultOutput) +} + +// A collection of arguments for invoking getMongodbflexInstance. +type LookupMongodbflexInstanceOutputArgs struct { + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupMongodbflexInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMongodbflexInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getMongodbflexInstance. +type LookupMongodbflexInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupMongodbflexInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMongodbflexInstanceResult)(nil)).Elem() +} + +func (o LookupMongodbflexInstanceResultOutput) ToLookupMongodbflexInstanceResultOutput() LookupMongodbflexInstanceResultOutput { + return o +} + +func (o LookupMongodbflexInstanceResultOutput) ToLookupMongodbflexInstanceResultOutputWithContext(ctx context.Context) LookupMongodbflexInstanceResultOutput { + return o +} + +// The Access Control List (ACL) for the MongoDB Flex instance. +func (o LookupMongodbflexInstanceResultOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). +func (o LookupMongodbflexInstanceResultOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexInstanceResultOutput) Flavor() GetMongodbflexInstanceFlavorOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) GetMongodbflexInstanceFlavor { return v.Flavor }).(GetMongodbflexInstanceFlavorOutput) +} + +func (o LookupMongodbflexInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the MongoDB Flex instance. +func (o LookupMongodbflexInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupMongodbflexInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Custom parameters for the MongoDB Flex instance. +func (o LookupMongodbflexInstanceResultOutput) Options() GetMongodbflexInstanceOptionsOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) GetMongodbflexInstanceOptions { return v.Options }).(GetMongodbflexInstanceOptionsOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupMongodbflexInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexInstanceResultOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) int { return v.Replicas }).(pulumi.IntOutput) +} + +func (o LookupMongodbflexInstanceResultOutput) Storage() GetMongodbflexInstanceStorageOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) GetMongodbflexInstanceStorage { return v.Storage }).(GetMongodbflexInstanceStorageOutput) +} + +func (o LookupMongodbflexInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupMongodbflexInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getMongodbflexUser.go b/sdk/go/stackit/getMongodbflexUser.go new file mode 100644 index 0000000..62ee816 --- /dev/null +++ b/sdk/go/stackit/getMongodbflexUser.go @@ -0,0 +1,132 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupMongodbflexUser(ctx *pulumi.Context, args *LookupMongodbflexUserArgs, opts ...pulumi.InvokeOption) (*LookupMongodbflexUserResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupMongodbflexUserResult + err := ctx.Invoke("stackit:index/getMongodbflexUser:getMongodbflexUser", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getMongodbflexUser. +type LookupMongodbflexUserArgs struct { + // ID of the MongoDB Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // User ID. + UserId string `pulumi:"userId"` +} + +// A collection of values returned by getMongodbflexUser. +type LookupMongodbflexUserResult struct { + Database string `pulumi:"database"` + Host string `pulumi:"host"` + Id string `pulumi:"id"` + // ID of the MongoDB Flex instance. + InstanceId string `pulumi:"instanceId"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Roles []string `pulumi:"roles"` + // User ID. + UserId string `pulumi:"userId"` + Username string `pulumi:"username"` +} + +func LookupMongodbflexUserOutput(ctx *pulumi.Context, args LookupMongodbflexUserOutputArgs, opts ...pulumi.InvokeOption) LookupMongodbflexUserResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupMongodbflexUserResultOutput, error) { + args := v.(LookupMongodbflexUserArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getMongodbflexUser:getMongodbflexUser", args, LookupMongodbflexUserResultOutput{}, options).(LookupMongodbflexUserResultOutput), nil + }).(LookupMongodbflexUserResultOutput) +} + +// A collection of arguments for invoking getMongodbflexUser. +type LookupMongodbflexUserOutputArgs struct { + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // User ID. + UserId pulumi.StringInput `pulumi:"userId"` +} + +func (LookupMongodbflexUserOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMongodbflexUserArgs)(nil)).Elem() +} + +// A collection of values returned by getMongodbflexUser. +type LookupMongodbflexUserResultOutput struct{ *pulumi.OutputState } + +func (LookupMongodbflexUserResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMongodbflexUserResult)(nil)).Elem() +} + +func (o LookupMongodbflexUserResultOutput) ToLookupMongodbflexUserResultOutput() LookupMongodbflexUserResultOutput { + return o +} + +func (o LookupMongodbflexUserResultOutput) ToLookupMongodbflexUserResultOutputWithContext(ctx context.Context) LookupMongodbflexUserResultOutput { + return o +} + +func (o LookupMongodbflexUserResultOutput) Database() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.Database }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexUserResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexUserResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the MongoDB Flex instance. +func (o LookupMongodbflexUserResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexUserResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupMongodbflexUserResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexUserResultOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) []string { return v.Roles }).(pulumi.StringArrayOutput) +} + +// User ID. +func (o LookupMongodbflexUserResultOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.UserId }).(pulumi.StringOutput) +} + +func (o LookupMongodbflexUserResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupMongodbflexUserResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupMongodbflexUserResultOutput{}) +} diff --git a/sdk/go/stackit/getNetwork.go b/sdk/go/stackit/getNetwork.go new file mode 100644 index 0000000..494dfb6 --- /dev/null +++ b/sdk/go/stackit/getNetwork.go @@ -0,0 +1,224 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupNetwork(ctx *pulumi.Context, args *LookupNetworkArgs, opts ...pulumi.InvokeOption) (*LookupNetworkResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupNetworkResult + err := ctx.Invoke("stackit:index/getNetwork:getNetwork", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getNetwork. +type LookupNetworkArgs struct { + // The network ID. + NetworkId string `pulumi:"networkId"` + // STACKIT project ID to which the network is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getNetwork. +type LookupNetworkResult struct { + Id string `pulumi:"id"` + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway string `pulumi:"ipv4Gateway"` + // The IPv4 nameservers of the network. + Ipv4Nameservers []string `pulumi:"ipv4Nameservers"` + // The IPv4 prefix of the network (CIDR). + // + // Deprecated: The API supports reading multiple prefixes. So using the attribute 'ipv4_prefixes` should be preferred. This attribute will be populated with the first element from the list + Ipv4Prefix string `pulumi:"ipv4Prefix"` + // The IPv4 prefix length of the network. + Ipv4PrefixLength int `pulumi:"ipv4PrefixLength"` + // The IPv4 prefixes of the network. + Ipv4Prefixes []string `pulumi:"ipv4Prefixes"` + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway string `pulumi:"ipv6Gateway"` + // The IPv6 nameservers of the network. + Ipv6Nameservers []string `pulumi:"ipv6Nameservers"` + // The IPv6 prefix of the network (CIDR). + // + // Deprecated: The API supports reading multiple prefixes. So using the attribute 'ipv6_prefixes` should be preferred. This attribute will be populated with the first element from the list + Ipv6Prefix string `pulumi:"ipv6Prefix"` + // The IPv6 prefix length of the network. + Ipv6PrefixLength int `pulumi:"ipv6PrefixLength"` + // The IPv6 prefixes of the network. + Ipv6Prefixes []string `pulumi:"ipv6Prefixes"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the network. + Name string `pulumi:"name"` + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers []string `pulumi:"nameservers"` + // The network ID. + NetworkId string `pulumi:"networkId"` + // The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + // + // Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + Prefixes []string `pulumi:"prefixes"` + // STACKIT project ID to which the network is associated. + ProjectId string `pulumi:"projectId"` + // The public IP of the network. + PublicIp string `pulumi:"publicIp"` + // Shows if the network is routed and therefore accessible from other networks. + Routed bool `pulumi:"routed"` +} + +func LookupNetworkOutput(ctx *pulumi.Context, args LookupNetworkOutputArgs, opts ...pulumi.InvokeOption) LookupNetworkResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupNetworkResultOutput, error) { + args := v.(LookupNetworkArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getNetwork:getNetwork", args, LookupNetworkResultOutput{}, options).(LookupNetworkResultOutput), nil + }).(LookupNetworkResultOutput) +} + +// A collection of arguments for invoking getNetwork. +type LookupNetworkOutputArgs struct { + // The network ID. + NetworkId pulumi.StringInput `pulumi:"networkId"` + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupNetworkOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkArgs)(nil)).Elem() +} + +// A collection of values returned by getNetwork. +type LookupNetworkResultOutput struct{ *pulumi.OutputState } + +func (LookupNetworkResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkResult)(nil)).Elem() +} + +func (o LookupNetworkResultOutput) ToLookupNetworkResultOutput() LookupNetworkResultOutput { + return o +} + +func (o LookupNetworkResultOutput) ToLookupNetworkResultOutputWithContext(ctx context.Context) LookupNetworkResultOutput { + return o +} + +func (o LookupNetworkResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. +func (o LookupNetworkResultOutput) Ipv4Gateway() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Ipv4Gateway }).(pulumi.StringOutput) +} + +// The IPv4 nameservers of the network. +func (o LookupNetworkResultOutput) Ipv4Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Ipv4Nameservers }).(pulumi.StringArrayOutput) +} + +// The IPv4 prefix of the network (CIDR). +// +// Deprecated: The API supports reading multiple prefixes. So using the attribute 'ipv4_prefixes` should be preferred. This attribute will be populated with the first element from the list +func (o LookupNetworkResultOutput) Ipv4Prefix() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Ipv4Prefix }).(pulumi.StringOutput) +} + +// The IPv4 prefix length of the network. +func (o LookupNetworkResultOutput) Ipv4PrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkResult) int { return v.Ipv4PrefixLength }).(pulumi.IntOutput) +} + +// The IPv4 prefixes of the network. +func (o LookupNetworkResultOutput) Ipv4Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Ipv4Prefixes }).(pulumi.StringArrayOutput) +} + +// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. +func (o LookupNetworkResultOutput) Ipv6Gateway() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Ipv6Gateway }).(pulumi.StringOutput) +} + +// The IPv6 nameservers of the network. +func (o LookupNetworkResultOutput) Ipv6Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Ipv6Nameservers }).(pulumi.StringArrayOutput) +} + +// The IPv6 prefix of the network (CIDR). +// +// Deprecated: The API supports reading multiple prefixes. So using the attribute 'ipv6_prefixes` should be preferred. This attribute will be populated with the first element from the list +func (o LookupNetworkResultOutput) Ipv6Prefix() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Ipv6Prefix }).(pulumi.StringOutput) +} + +// The IPv6 prefix length of the network. +func (o LookupNetworkResultOutput) Ipv6PrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkResult) int { return v.Ipv6PrefixLength }).(pulumi.IntOutput) +} + +// The IPv6 prefixes of the network. +func (o LookupNetworkResultOutput) Ipv6Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Ipv6Prefixes }).(pulumi.StringArrayOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupNetworkResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupNetworkResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the network. +func (o LookupNetworkResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. +// +// Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. +func (o LookupNetworkResultOutput) Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Nameservers }).(pulumi.StringArrayOutput) +} + +// The network ID. +func (o LookupNetworkResultOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.NetworkId }).(pulumi.StringOutput) +} + +// The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. +// +// Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. +func (o LookupNetworkResultOutput) Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkResult) []string { return v.Prefixes }).(pulumi.StringArrayOutput) +} + +// STACKIT project ID to which the network is associated. +func (o LookupNetworkResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The public IP of the network. +func (o LookupNetworkResultOutput) PublicIp() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkResult) string { return v.PublicIp }).(pulumi.StringOutput) +} + +// Shows if the network is routed and therefore accessible from other networks. +func (o LookupNetworkResultOutput) Routed() pulumi.BoolOutput { + return o.ApplyT(func(v LookupNetworkResult) bool { return v.Routed }).(pulumi.BoolOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupNetworkResultOutput{}) +} diff --git a/sdk/go/stackit/getNetworkArea.go b/sdk/go/stackit/getNetworkArea.go new file mode 100644 index 0000000..1112ddf --- /dev/null +++ b/sdk/go/stackit/getNetworkArea.go @@ -0,0 +1,159 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network area datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupNetworkArea(ctx *pulumi.Context, args *LookupNetworkAreaArgs, opts ...pulumi.InvokeOption) (*LookupNetworkAreaResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupNetworkAreaResult + err := ctx.Invoke("stackit:index/getNetworkArea:getNetworkArea", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getNetworkArea. +type LookupNetworkAreaArgs struct { + // The network area ID. + NetworkAreaId string `pulumi:"networkAreaId"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` +} + +// A collection of values returned by getNetworkArea. +type LookupNetworkAreaResult struct { + // List of DNS Servers/Nameservers. + DefaultNameservers []string `pulumi:"defaultNameservers"` + // The default prefix length for networks in the network area. + DefaultPrefixLength int `pulumi:"defaultPrefixLength"` + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The maximal prefix length for networks in the network area. + MaxPrefixLength int `pulumi:"maxPrefixLength"` + // The minimal prefix length for networks in the network area. + MinPrefixLength int `pulumi:"minPrefixLength"` + // The name of the network area. + Name string `pulumi:"name"` + // The network area ID. + NetworkAreaId string `pulumi:"networkAreaId"` + // List of Network ranges. + NetworkRanges []GetNetworkAreaNetworkRange `pulumi:"networkRanges"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` + // The amount of projects currently referencing this area. + ProjectCount int `pulumi:"projectCount"` + // Classless Inter-Domain Routing (CIDR). + TransferNetwork string `pulumi:"transferNetwork"` +} + +func LookupNetworkAreaOutput(ctx *pulumi.Context, args LookupNetworkAreaOutputArgs, opts ...pulumi.InvokeOption) LookupNetworkAreaResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupNetworkAreaResultOutput, error) { + args := v.(LookupNetworkAreaArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getNetworkArea:getNetworkArea", args, LookupNetworkAreaResultOutput{}, options).(LookupNetworkAreaResultOutput), nil + }).(LookupNetworkAreaResultOutput) +} + +// A collection of arguments for invoking getNetworkArea. +type LookupNetworkAreaOutputArgs struct { + // The network area ID. + NetworkAreaId pulumi.StringInput `pulumi:"networkAreaId"` + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringInput `pulumi:"organizationId"` +} + +func (LookupNetworkAreaOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkAreaArgs)(nil)).Elem() +} + +// A collection of values returned by getNetworkArea. +type LookupNetworkAreaResultOutput struct{ *pulumi.OutputState } + +func (LookupNetworkAreaResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkAreaResult)(nil)).Elem() +} + +func (o LookupNetworkAreaResultOutput) ToLookupNetworkAreaResultOutput() LookupNetworkAreaResultOutput { + return o +} + +func (o LookupNetworkAreaResultOutput) ToLookupNetworkAreaResultOutputWithContext(ctx context.Context) LookupNetworkAreaResultOutput { + return o +} + +// List of DNS Servers/Nameservers. +func (o LookupNetworkAreaResultOutput) DefaultNameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) []string { return v.DefaultNameservers }).(pulumi.StringArrayOutput) +} + +// The default prefix length for networks in the network area. +func (o LookupNetworkAreaResultOutput) DefaultPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) int { return v.DefaultPrefixLength }).(pulumi.IntOutput) +} + +func (o LookupNetworkAreaResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupNetworkAreaResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The maximal prefix length for networks in the network area. +func (o LookupNetworkAreaResultOutput) MaxPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) int { return v.MaxPrefixLength }).(pulumi.IntOutput) +} + +// The minimal prefix length for networks in the network area. +func (o LookupNetworkAreaResultOutput) MinPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) int { return v.MinPrefixLength }).(pulumi.IntOutput) +} + +// The name of the network area. +func (o LookupNetworkAreaResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The network area ID. +func (o LookupNetworkAreaResultOutput) NetworkAreaId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) string { return v.NetworkAreaId }).(pulumi.StringOutput) +} + +// List of Network ranges. +func (o LookupNetworkAreaResultOutput) NetworkRanges() GetNetworkAreaNetworkRangeArrayOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) []GetNetworkAreaNetworkRange { return v.NetworkRanges }).(GetNetworkAreaNetworkRangeArrayOutput) +} + +// STACKIT organization ID to which the network area is associated. +func (o LookupNetworkAreaResultOutput) OrganizationId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) string { return v.OrganizationId }).(pulumi.StringOutput) +} + +// The amount of projects currently referencing this area. +func (o LookupNetworkAreaResultOutput) ProjectCount() pulumi.IntOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) int { return v.ProjectCount }).(pulumi.IntOutput) +} + +// Classless Inter-Domain Routing (CIDR). +func (o LookupNetworkAreaResultOutput) TransferNetwork() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaResult) string { return v.TransferNetwork }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupNetworkAreaResultOutput{}) +} diff --git a/sdk/go/stackit/getNetworkAreaRoute.go b/sdk/go/stackit/getNetworkAreaRoute.go new file mode 100644 index 0000000..463e284 --- /dev/null +++ b/sdk/go/stackit/getNetworkAreaRoute.go @@ -0,0 +1,128 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network area route data resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupNetworkAreaRoute(ctx *pulumi.Context, args *LookupNetworkAreaRouteArgs, opts ...pulumi.InvokeOption) (*LookupNetworkAreaRouteResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupNetworkAreaRouteResult + err := ctx.Invoke("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getNetworkAreaRoute. +type LookupNetworkAreaRouteArgs struct { + // The network area ID to which the network area route is associated. + NetworkAreaId string `pulumi:"networkAreaId"` + // The network area route ID. + NetworkAreaRouteId string `pulumi:"networkAreaRouteId"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` +} + +// A collection of values returned by getNetworkAreaRoute. +type LookupNetworkAreaRouteResult struct { + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The network area ID to which the network area route is associated. + NetworkAreaId string `pulumi:"networkAreaId"` + // The network area route ID. + NetworkAreaRouteId string `pulumi:"networkAreaRouteId"` + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop string `pulumi:"nextHop"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix string `pulumi:"prefix"` +} + +func LookupNetworkAreaRouteOutput(ctx *pulumi.Context, args LookupNetworkAreaRouteOutputArgs, opts ...pulumi.InvokeOption) LookupNetworkAreaRouteResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupNetworkAreaRouteResultOutput, error) { + args := v.(LookupNetworkAreaRouteArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", args, LookupNetworkAreaRouteResultOutput{}, options).(LookupNetworkAreaRouteResultOutput), nil + }).(LookupNetworkAreaRouteResultOutput) +} + +// A collection of arguments for invoking getNetworkAreaRoute. +type LookupNetworkAreaRouteOutputArgs struct { + // The network area ID to which the network area route is associated. + NetworkAreaId pulumi.StringInput `pulumi:"networkAreaId"` + // The network area route ID. + NetworkAreaRouteId pulumi.StringInput `pulumi:"networkAreaRouteId"` + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringInput `pulumi:"organizationId"` +} + +func (LookupNetworkAreaRouteOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkAreaRouteArgs)(nil)).Elem() +} + +// A collection of values returned by getNetworkAreaRoute. +type LookupNetworkAreaRouteResultOutput struct{ *pulumi.OutputState } + +func (LookupNetworkAreaRouteResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkAreaRouteResult)(nil)).Elem() +} + +func (o LookupNetworkAreaRouteResultOutput) ToLookupNetworkAreaRouteResultOutput() LookupNetworkAreaRouteResultOutput { + return o +} + +func (o LookupNetworkAreaRouteResultOutput) ToLookupNetworkAreaRouteResultOutputWithContext(ctx context.Context) LookupNetworkAreaRouteResultOutput { + return o +} + +func (o LookupNetworkAreaRouteResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupNetworkAreaRouteResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The network area ID to which the network area route is associated. +func (o LookupNetworkAreaRouteResultOutput) NetworkAreaId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.NetworkAreaId }).(pulumi.StringOutput) +} + +// The network area route ID. +func (o LookupNetworkAreaRouteResultOutput) NetworkAreaRouteId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.NetworkAreaRouteId }).(pulumi.StringOutput) +} + +// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. +func (o LookupNetworkAreaRouteResultOutput) NextHop() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.NextHop }).(pulumi.StringOutput) +} + +// STACKIT organization ID to which the network area is associated. +func (o LookupNetworkAreaRouteResultOutput) OrganizationId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.OrganizationId }).(pulumi.StringOutput) +} + +// The network, that is reachable though the Next Hop. Should use CIDR notation. +func (o LookupNetworkAreaRouteResultOutput) Prefix() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkAreaRouteResult) string { return v.Prefix }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupNetworkAreaRouteResultOutput{}) +} diff --git a/sdk/go/stackit/getNetworkInterface.go b/sdk/go/stackit/getNetworkInterface.go new file mode 100644 index 0000000..3dd4d9e --- /dev/null +++ b/sdk/go/stackit/getNetworkInterface.go @@ -0,0 +1,170 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network interface datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupNetworkInterface(ctx *pulumi.Context, args *LookupNetworkInterfaceArgs, opts ...pulumi.InvokeOption) (*LookupNetworkInterfaceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupNetworkInterfaceResult + err := ctx.Invoke("stackit:index/getNetworkInterface:getNetworkInterface", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getNetworkInterface. +type LookupNetworkInterfaceArgs struct { + // The network ID to which the network interface is associated. + NetworkId string `pulumi:"networkId"` + // The network interface ID. + NetworkInterfaceId string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getNetworkInterface. +type LookupNetworkInterfaceResult struct { + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses []string `pulumi:"allowedAddresses"` + // The device UUID of the network interface. + Device string `pulumi:"device"` + Id string `pulumi:"id"` + // The IPv4 address. + Ipv4 string `pulumi:"ipv4"` + // Labels are key-value string pairs which can be attached to a network interface. + Labels map[string]string `pulumi:"labels"` + // The MAC address of network interface. + Mac string `pulumi:"mac"` + // The name of the network interface. + Name string `pulumi:"name"` + // The network ID to which the network interface is associated. + NetworkId string `pulumi:"networkId"` + // The network interface ID. + NetworkInterfaceId string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface is associated. + ProjectId string `pulumi:"projectId"` + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security bool `pulumi:"security"` + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds []string `pulumi:"securityGroupIds"` + // Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + Type string `pulumi:"type"` +} + +func LookupNetworkInterfaceOutput(ctx *pulumi.Context, args LookupNetworkInterfaceOutputArgs, opts ...pulumi.InvokeOption) LookupNetworkInterfaceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupNetworkInterfaceResultOutput, error) { + args := v.(LookupNetworkInterfaceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getNetworkInterface:getNetworkInterface", args, LookupNetworkInterfaceResultOutput{}, options).(LookupNetworkInterfaceResultOutput), nil + }).(LookupNetworkInterfaceResultOutput) +} + +// A collection of arguments for invoking getNetworkInterface. +type LookupNetworkInterfaceOutputArgs struct { + // The network ID to which the network interface is associated. + NetworkId pulumi.StringInput `pulumi:"networkId"` + // The network interface ID. + NetworkInterfaceId pulumi.StringInput `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupNetworkInterfaceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkInterfaceArgs)(nil)).Elem() +} + +// A collection of values returned by getNetworkInterface. +type LookupNetworkInterfaceResultOutput struct{ *pulumi.OutputState } + +func (LookupNetworkInterfaceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupNetworkInterfaceResult)(nil)).Elem() +} + +func (o LookupNetworkInterfaceResultOutput) ToLookupNetworkInterfaceResultOutput() LookupNetworkInterfaceResultOutput { + return o +} + +func (o LookupNetworkInterfaceResultOutput) ToLookupNetworkInterfaceResultOutputWithContext(ctx context.Context) LookupNetworkInterfaceResultOutput { + return o +} + +// The list of CIDR (Classless Inter-Domain Routing) notations. +func (o LookupNetworkInterfaceResultOutput) AllowedAddresses() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) []string { return v.AllowedAddresses }).(pulumi.StringArrayOutput) +} + +// The device UUID of the network interface. +func (o LookupNetworkInterfaceResultOutput) Device() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Device }).(pulumi.StringOutput) +} + +func (o LookupNetworkInterfaceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The IPv4 address. +func (o LookupNetworkInterfaceResultOutput) Ipv4() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Ipv4 }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a network interface. +func (o LookupNetworkInterfaceResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The MAC address of network interface. +func (o LookupNetworkInterfaceResultOutput) Mac() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Mac }).(pulumi.StringOutput) +} + +// The name of the network interface. +func (o LookupNetworkInterfaceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The network ID to which the network interface is associated. +func (o LookupNetworkInterfaceResultOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.NetworkId }).(pulumi.StringOutput) +} + +// The network interface ID. +func (o LookupNetworkInterfaceResultOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the network interface is associated. +func (o LookupNetworkInterfaceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The Network Interface Security. If set to false, then no security groups will apply to this network interface. +func (o LookupNetworkInterfaceResultOutput) Security() pulumi.BoolOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) bool { return v.Security }).(pulumi.BoolOutput) +} + +// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. +func (o LookupNetworkInterfaceResultOutput) SecurityGroupIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) []string { return v.SecurityGroupIds }).(pulumi.StringArrayOutput) +} + +// Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. +func (o LookupNetworkInterfaceResultOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v LookupNetworkInterfaceResult) string { return v.Type }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupNetworkInterfaceResultOutput{}) +} diff --git a/sdk/go/stackit/getObjectstorageBucket.go b/sdk/go/stackit/getObjectstorageBucket.go new file mode 100644 index 0000000..106b066 --- /dev/null +++ b/sdk/go/stackit/getObjectstorageBucket.go @@ -0,0 +1,117 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObjectstorageBucket(ctx *pulumi.Context, args *LookupObjectstorageBucketArgs, opts ...pulumi.InvokeOption) (*LookupObjectstorageBucketResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObjectstorageBucketResult + err := ctx.Invoke("stackit:index/getObjectstorageBucket:getObjectstorageBucket", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObjectstorageBucket. +type LookupObjectstorageBucketArgs struct { + // The bucket name. It must be DNS conform. + Name string `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getObjectstorageBucket. +type LookupObjectstorageBucketResult struct { + Id string `pulumi:"id"` + // The bucket name. It must be DNS conform. + Name string `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + UrlPathStyle string `pulumi:"urlPathStyle"` + UrlVirtualHostedStyle string `pulumi:"urlVirtualHostedStyle"` +} + +func LookupObjectstorageBucketOutput(ctx *pulumi.Context, args LookupObjectstorageBucketOutputArgs, opts ...pulumi.InvokeOption) LookupObjectstorageBucketResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObjectstorageBucketResultOutput, error) { + args := v.(LookupObjectstorageBucketArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObjectstorageBucket:getObjectstorageBucket", args, LookupObjectstorageBucketResultOutput{}, options).(LookupObjectstorageBucketResultOutput), nil + }).(LookupObjectstorageBucketResultOutput) +} + +// A collection of arguments for invoking getObjectstorageBucket. +type LookupObjectstorageBucketOutputArgs struct { + // The bucket name. It must be DNS conform. + Name pulumi.StringInput `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupObjectstorageBucketOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageBucketArgs)(nil)).Elem() +} + +// A collection of values returned by getObjectstorageBucket. +type LookupObjectstorageBucketResultOutput struct{ *pulumi.OutputState } + +func (LookupObjectstorageBucketResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageBucketResult)(nil)).Elem() +} + +func (o LookupObjectstorageBucketResultOutput) ToLookupObjectstorageBucketResultOutput() LookupObjectstorageBucketResultOutput { + return o +} + +func (o LookupObjectstorageBucketResultOutput) ToLookupObjectstorageBucketResultOutputWithContext(ctx context.Context) LookupObjectstorageBucketResultOutput { + return o +} + +func (o LookupObjectstorageBucketResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The bucket name. It must be DNS conform. +func (o LookupObjectstorageBucketResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the bucket is associated. +func (o LookupObjectstorageBucketResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupObjectstorageBucketResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func (o LookupObjectstorageBucketResultOutput) UrlPathStyle() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) string { return v.UrlPathStyle }).(pulumi.StringOutput) +} + +func (o LookupObjectstorageBucketResultOutput) UrlVirtualHostedStyle() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageBucketResult) string { return v.UrlVirtualHostedStyle }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObjectstorageBucketResultOutput{}) +} diff --git a/sdk/go/stackit/getObjectstorageCredential.go b/sdk/go/stackit/getObjectstorageCredential.go new file mode 100644 index 0000000..6a9167f --- /dev/null +++ b/sdk/go/stackit/getObjectstorageCredential.go @@ -0,0 +1,128 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObjectstorageCredential(ctx *pulumi.Context, args *LookupObjectstorageCredentialArgs, opts ...pulumi.InvokeOption) (*LookupObjectstorageCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObjectstorageCredentialResult + err := ctx.Invoke("stackit:index/getObjectstorageCredential:getObjectstorageCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObjectstorageCredential. +type LookupObjectstorageCredentialArgs struct { + // The credential ID. + CredentialId string `pulumi:"credentialId"` + // The credential group ID. + CredentialsGroupId string `pulumi:"credentialsGroupId"` + // STACKIT Project ID to which the credential group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getObjectstorageCredential. +type LookupObjectstorageCredentialResult struct { + // The credential ID. + CredentialId string `pulumi:"credentialId"` + // The credential group ID. + CredentialsGroupId string `pulumi:"credentialsGroupId"` + ExpirationTimestamp string `pulumi:"expirationTimestamp"` + Id string `pulumi:"id"` + Name string `pulumi:"name"` + // STACKIT Project ID to which the credential group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +func LookupObjectstorageCredentialOutput(ctx *pulumi.Context, args LookupObjectstorageCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupObjectstorageCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObjectstorageCredentialResultOutput, error) { + args := v.(LookupObjectstorageCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObjectstorageCredential:getObjectstorageCredential", args, LookupObjectstorageCredentialResultOutput{}, options).(LookupObjectstorageCredentialResultOutput), nil + }).(LookupObjectstorageCredentialResultOutput) +} + +// A collection of arguments for invoking getObjectstorageCredential. +type LookupObjectstorageCredentialOutputArgs struct { + // The credential ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // The credential group ID. + CredentialsGroupId pulumi.StringInput `pulumi:"credentialsGroupId"` + // STACKIT Project ID to which the credential group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupObjectstorageCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getObjectstorageCredential. +type LookupObjectstorageCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupObjectstorageCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageCredentialResult)(nil)).Elem() +} + +func (o LookupObjectstorageCredentialResultOutput) ToLookupObjectstorageCredentialResultOutput() LookupObjectstorageCredentialResultOutput { + return o +} + +func (o LookupObjectstorageCredentialResultOutput) ToLookupObjectstorageCredentialResultOutputWithContext(ctx context.Context) LookupObjectstorageCredentialResultOutput { + return o +} + +// The credential ID. +func (o LookupObjectstorageCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +// The credential group ID. +func (o LookupObjectstorageCredentialResultOutput) CredentialsGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.CredentialsGroupId }).(pulumi.StringOutput) +} + +func (o LookupObjectstorageCredentialResultOutput) ExpirationTimestamp() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.ExpirationTimestamp }).(pulumi.StringOutput) +} + +func (o LookupObjectstorageCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupObjectstorageCredentialResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the credential group is associated. +func (o LookupObjectstorageCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupObjectstorageCredentialResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObjectstorageCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getObjectstorageCredentialsGroup.go b/sdk/go/stackit/getObjectstorageCredentialsGroup.go new file mode 100644 index 0000000..5d9357c --- /dev/null +++ b/sdk/go/stackit/getObjectstorageCredentialsGroup.go @@ -0,0 +1,121 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObjectstorageCredentialsGroup(ctx *pulumi.Context, args *LookupObjectstorageCredentialsGroupArgs, opts ...pulumi.InvokeOption) (*LookupObjectstorageCredentialsGroupResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObjectstorageCredentialsGroupResult + err := ctx.Invoke("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObjectstorageCredentialsGroup. +type LookupObjectstorageCredentialsGroupArgs struct { + // The credentials group ID. + CredentialsGroupId string `pulumi:"credentialsGroupId"` + // Object Storage Project ID to which the credentials group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getObjectstorageCredentialsGroup. +type LookupObjectstorageCredentialsGroupResult struct { + // The credentials group ID. + CredentialsGroupId string `pulumi:"credentialsGroupId"` + Id string `pulumi:"id"` + // The credentials group's display name. + Name string `pulumi:"name"` + // Object Storage Project ID to which the credentials group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Credentials group uniform resource name (URN) + Urn string `pulumi:"urn"` +} + +func LookupObjectstorageCredentialsGroupOutput(ctx *pulumi.Context, args LookupObjectstorageCredentialsGroupOutputArgs, opts ...pulumi.InvokeOption) LookupObjectstorageCredentialsGroupResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObjectstorageCredentialsGroupResultOutput, error) { + args := v.(LookupObjectstorageCredentialsGroupArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", args, LookupObjectstorageCredentialsGroupResultOutput{}, options).(LookupObjectstorageCredentialsGroupResultOutput), nil + }).(LookupObjectstorageCredentialsGroupResultOutput) +} + +// A collection of arguments for invoking getObjectstorageCredentialsGroup. +type LookupObjectstorageCredentialsGroupOutputArgs struct { + // The credentials group ID. + CredentialsGroupId pulumi.StringInput `pulumi:"credentialsGroupId"` + // Object Storage Project ID to which the credentials group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupObjectstorageCredentialsGroupOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageCredentialsGroupArgs)(nil)).Elem() +} + +// A collection of values returned by getObjectstorageCredentialsGroup. +type LookupObjectstorageCredentialsGroupResultOutput struct{ *pulumi.OutputState } + +func (LookupObjectstorageCredentialsGroupResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObjectstorageCredentialsGroupResult)(nil)).Elem() +} + +func (o LookupObjectstorageCredentialsGroupResultOutput) ToLookupObjectstorageCredentialsGroupResultOutput() LookupObjectstorageCredentialsGroupResultOutput { + return o +} + +func (o LookupObjectstorageCredentialsGroupResultOutput) ToLookupObjectstorageCredentialsGroupResultOutputWithContext(ctx context.Context) LookupObjectstorageCredentialsGroupResultOutput { + return o +} + +// The credentials group ID. +func (o LookupObjectstorageCredentialsGroupResultOutput) CredentialsGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) string { return v.CredentialsGroupId }).(pulumi.StringOutput) +} + +func (o LookupObjectstorageCredentialsGroupResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The credentials group's display name. +func (o LookupObjectstorageCredentialsGroupResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Object Storage Project ID to which the credentials group is associated. +func (o LookupObjectstorageCredentialsGroupResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupObjectstorageCredentialsGroupResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Credentials group uniform resource name (URN) +func (o LookupObjectstorageCredentialsGroupResultOutput) Urn() pulumi.StringOutput { + return o.ApplyT(func(v LookupObjectstorageCredentialsGroupResult) string { return v.Urn }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObjectstorageCredentialsGroupResultOutput{}) +} diff --git a/sdk/go/stackit/getObservabilityAlertgroup.go b/sdk/go/stackit/getObservabilityAlertgroup.go new file mode 100644 index 0000000..291b7ab --- /dev/null +++ b/sdk/go/stackit/getObservabilityAlertgroup.go @@ -0,0 +1,119 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObservabilityAlertgroup(ctx *pulumi.Context, args *LookupObservabilityAlertgroupArgs, opts ...pulumi.InvokeOption) (*LookupObservabilityAlertgroupResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObservabilityAlertgroupResult + err := ctx.Invoke("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObservabilityAlertgroup. +type LookupObservabilityAlertgroupArgs struct { + // Observability instance ID to which the alert group is associated. + InstanceId string `pulumi:"instanceId"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name string `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getObservabilityAlertgroup. +type LookupObservabilityAlertgroupResult struct { + Id string `pulumi:"id"` + // Observability instance ID to which the alert group is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval string `pulumi:"interval"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name string `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId string `pulumi:"projectId"` + Rules []GetObservabilityAlertgroupRule `pulumi:"rules"` +} + +func LookupObservabilityAlertgroupOutput(ctx *pulumi.Context, args LookupObservabilityAlertgroupOutputArgs, opts ...pulumi.InvokeOption) LookupObservabilityAlertgroupResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObservabilityAlertgroupResultOutput, error) { + args := v.(LookupObservabilityAlertgroupArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", args, LookupObservabilityAlertgroupResultOutput{}, options).(LookupObservabilityAlertgroupResultOutput), nil + }).(LookupObservabilityAlertgroupResultOutput) +} + +// A collection of arguments for invoking getObservabilityAlertgroup. +type LookupObservabilityAlertgroupOutputArgs struct { + // Observability instance ID to which the alert group is associated. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupObservabilityAlertgroupOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityAlertgroupArgs)(nil)).Elem() +} + +// A collection of values returned by getObservabilityAlertgroup. +type LookupObservabilityAlertgroupResultOutput struct{ *pulumi.OutputState } + +func (LookupObservabilityAlertgroupResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityAlertgroupResult)(nil)).Elem() +} + +func (o LookupObservabilityAlertgroupResultOutput) ToLookupObservabilityAlertgroupResultOutput() LookupObservabilityAlertgroupResultOutput { + return o +} + +func (o LookupObservabilityAlertgroupResultOutput) ToLookupObservabilityAlertgroupResultOutputWithContext(ctx context.Context) LookupObservabilityAlertgroupResultOutput { + return o +} + +func (o LookupObservabilityAlertgroupResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Observability instance ID to which the alert group is associated. +func (o LookupObservabilityAlertgroupResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. +func (o LookupObservabilityAlertgroupResultOutput) Interval() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) string { return v.Interval }).(pulumi.StringOutput) +} + +// The name of the alert group. Is the identifier and must be unique in the group. +func (o LookupObservabilityAlertgroupResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the alert group is associated. +func (o LookupObservabilityAlertgroupResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupObservabilityAlertgroupResultOutput) Rules() GetObservabilityAlertgroupRuleArrayOutput { + return o.ApplyT(func(v LookupObservabilityAlertgroupResult) []GetObservabilityAlertgroupRule { return v.Rules }).(GetObservabilityAlertgroupRuleArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObservabilityAlertgroupResultOutput{}) +} diff --git a/sdk/go/stackit/getObservabilityInstance.go b/sdk/go/stackit/getObservabilityInstance.go new file mode 100644 index 0000000..0387b80 --- /dev/null +++ b/sdk/go/stackit/getObservabilityInstance.go @@ -0,0 +1,263 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObservabilityInstance(ctx *pulumi.Context, args *LookupObservabilityInstanceArgs, opts ...pulumi.InvokeOption) (*LookupObservabilityInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObservabilityInstanceResult + err := ctx.Invoke("stackit:index/getObservabilityInstance:getObservabilityInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObservabilityInstance. +type LookupObservabilityInstanceArgs struct { + // The Observability instance ID. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getObservabilityInstance. +type LookupObservabilityInstanceResult struct { + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls []string `pulumi:"acls"` + // Alert configuration for the instance. + AlertConfig GetObservabilityInstanceAlertConfig `pulumi:"alertConfig"` + // Specifies Alerting URL. + AlertingUrl string `pulumi:"alertingUrl"` + // Specifies Observability instance dashboard URL. + DashboardUrl string `pulumi:"dashboardUrl"` + // Specifies an initial Grafana admin password. + GrafanaInitialAdminPassword string `pulumi:"grafanaInitialAdminPassword"` + // Specifies an initial Grafana admin username. + GrafanaInitialAdminUser string `pulumi:"grafanaInitialAdminUser"` + // If true, anyone can access Grafana dashboards without logging in. + GrafanaPublicReadAccess bool `pulumi:"grafanaPublicReadAccess"` + // Specifies Grafana URL. + GrafanaUrl string `pulumi:"grafanaUrl"` + Id string `pulumi:"id"` + // The Observability instance ID. + InstanceId string `pulumi:"instanceId"` + // Specifies if the instance can be updated. + IsUpdatable bool `pulumi:"isUpdatable"` + JaegerTracesUrl string `pulumi:"jaegerTracesUrl"` + JaegerUiUrl string `pulumi:"jaegerUiUrl"` + // Specifies URL for pushing logs. + LogsPushUrl string `pulumi:"logsPushUrl"` + // Specifies Logs URL. + LogsUrl string `pulumi:"logsUrl"` + // Specifies URL for pushing metrics. + MetricsPushUrl string `pulumi:"metricsPushUrl"` + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays int `pulumi:"metricsRetentionDays"` + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling int `pulumi:"metricsRetentionDays1hDownsampling"` + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling int `pulumi:"metricsRetentionDays5mDownsampling"` + // Specifies metrics URL. + MetricsUrl string `pulumi:"metricsUrl"` + // The name of the Observability instance. + Name string `pulumi:"name"` + OtlpTracesUrl string `pulumi:"otlpTracesUrl"` + // Additional parameters. + Parameters map[string]string `pulumi:"parameters"` + // The Observability plan ID. + PlanId string `pulumi:"planId"` + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // Specifies Targets URL. + TargetsUrl string `pulumi:"targetsUrl"` + ZipkinSpansUrl string `pulumi:"zipkinSpansUrl"` +} + +func LookupObservabilityInstanceOutput(ctx *pulumi.Context, args LookupObservabilityInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupObservabilityInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObservabilityInstanceResultOutput, error) { + args := v.(LookupObservabilityInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObservabilityInstance:getObservabilityInstance", args, LookupObservabilityInstanceResultOutput{}, options).(LookupObservabilityInstanceResultOutput), nil + }).(LookupObservabilityInstanceResultOutput) +} + +// A collection of arguments for invoking getObservabilityInstance. +type LookupObservabilityInstanceOutputArgs struct { + // The Observability instance ID. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupObservabilityInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getObservabilityInstance. +type LookupObservabilityInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupObservabilityInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityInstanceResult)(nil)).Elem() +} + +func (o LookupObservabilityInstanceResultOutput) ToLookupObservabilityInstanceResultOutput() LookupObservabilityInstanceResultOutput { + return o +} + +func (o LookupObservabilityInstanceResultOutput) ToLookupObservabilityInstanceResultOutputWithContext(ctx context.Context) LookupObservabilityInstanceResultOutput { + return o +} + +// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. +func (o LookupObservabilityInstanceResultOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +// Alert configuration for the instance. +func (o LookupObservabilityInstanceResultOutput) AlertConfig() GetObservabilityInstanceAlertConfigOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) GetObservabilityInstanceAlertConfig { return v.AlertConfig }).(GetObservabilityInstanceAlertConfigOutput) +} + +// Specifies Alerting URL. +func (o LookupObservabilityInstanceResultOutput) AlertingUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.AlertingUrl }).(pulumi.StringOutput) +} + +// Specifies Observability instance dashboard URL. +func (o LookupObservabilityInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +// Specifies an initial Grafana admin password. +func (o LookupObservabilityInstanceResultOutput) GrafanaInitialAdminPassword() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.GrafanaInitialAdminPassword }).(pulumi.StringOutput) +} + +// Specifies an initial Grafana admin username. +func (o LookupObservabilityInstanceResultOutput) GrafanaInitialAdminUser() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.GrafanaInitialAdminUser }).(pulumi.StringOutput) +} + +// If true, anyone can access Grafana dashboards without logging in. +func (o LookupObservabilityInstanceResultOutput) GrafanaPublicReadAccess() pulumi.BoolOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) bool { return v.GrafanaPublicReadAccess }).(pulumi.BoolOutput) +} + +// Specifies Grafana URL. +func (o LookupObservabilityInstanceResultOutput) GrafanaUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.GrafanaUrl }).(pulumi.StringOutput) +} + +func (o LookupObservabilityInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The Observability instance ID. +func (o LookupObservabilityInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies if the instance can be updated. +func (o LookupObservabilityInstanceResultOutput) IsUpdatable() pulumi.BoolOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) bool { return v.IsUpdatable }).(pulumi.BoolOutput) +} + +func (o LookupObservabilityInstanceResultOutput) JaegerTracesUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.JaegerTracesUrl }).(pulumi.StringOutput) +} + +func (o LookupObservabilityInstanceResultOutput) JaegerUiUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.JaegerUiUrl }).(pulumi.StringOutput) +} + +// Specifies URL for pushing logs. +func (o LookupObservabilityInstanceResultOutput) LogsPushUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.LogsPushUrl }).(pulumi.StringOutput) +} + +// Specifies Logs URL. +func (o LookupObservabilityInstanceResultOutput) LogsUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.LogsUrl }).(pulumi.StringOutput) +} + +// Specifies URL for pushing metrics. +func (o LookupObservabilityInstanceResultOutput) MetricsPushUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.MetricsPushUrl }).(pulumi.StringOutput) +} + +// Specifies for how many days the raw metrics are kept. +func (o LookupObservabilityInstanceResultOutput) MetricsRetentionDays() pulumi.IntOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) int { return v.MetricsRetentionDays }).(pulumi.IntOutput) +} + +// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). +func (o LookupObservabilityInstanceResultOutput) MetricsRetentionDays1hDownsampling() pulumi.IntOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) int { return v.MetricsRetentionDays1hDownsampling }).(pulumi.IntOutput) +} + +// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). +func (o LookupObservabilityInstanceResultOutput) MetricsRetentionDays5mDownsampling() pulumi.IntOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) int { return v.MetricsRetentionDays5mDownsampling }).(pulumi.IntOutput) +} + +// Specifies metrics URL. +func (o LookupObservabilityInstanceResultOutput) MetricsUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.MetricsUrl }).(pulumi.StringOutput) +} + +// The name of the Observability instance. +func (o LookupObservabilityInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupObservabilityInstanceResultOutput) OtlpTracesUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.OtlpTracesUrl }).(pulumi.StringOutput) +} + +// Additional parameters. +func (o LookupObservabilityInstanceResultOutput) Parameters() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) map[string]string { return v.Parameters }).(pulumi.StringMapOutput) +} + +// The Observability plan ID. +func (o LookupObservabilityInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. +func (o LookupObservabilityInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupObservabilityInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Specifies Targets URL. +func (o LookupObservabilityInstanceResultOutput) TargetsUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.TargetsUrl }).(pulumi.StringOutput) +} + +func (o LookupObservabilityInstanceResultOutput) ZipkinSpansUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityInstanceResult) string { return v.ZipkinSpansUrl }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObservabilityInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getObservabilityLogalertgroup.go b/sdk/go/stackit/getObservabilityLogalertgroup.go new file mode 100644 index 0000000..5e2f1c0 --- /dev/null +++ b/sdk/go/stackit/getObservabilityLogalertgroup.go @@ -0,0 +1,119 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObservabilityLogalertgroup(ctx *pulumi.Context, args *LookupObservabilityLogalertgroupArgs, opts ...pulumi.InvokeOption) (*LookupObservabilityLogalertgroupResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObservabilityLogalertgroupResult + err := ctx.Invoke("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObservabilityLogalertgroup. +type LookupObservabilityLogalertgroupArgs struct { + // Observability instance ID to which the log alert group is associated. + InstanceId string `pulumi:"instanceId"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name string `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getObservabilityLogalertgroup. +type LookupObservabilityLogalertgroupResult struct { + Id string `pulumi:"id"` + // Observability instance ID to which the log alert group is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval string `pulumi:"interval"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name string `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId string `pulumi:"projectId"` + Rules []GetObservabilityLogalertgroupRule `pulumi:"rules"` +} + +func LookupObservabilityLogalertgroupOutput(ctx *pulumi.Context, args LookupObservabilityLogalertgroupOutputArgs, opts ...pulumi.InvokeOption) LookupObservabilityLogalertgroupResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObservabilityLogalertgroupResultOutput, error) { + args := v.(LookupObservabilityLogalertgroupArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", args, LookupObservabilityLogalertgroupResultOutput{}, options).(LookupObservabilityLogalertgroupResultOutput), nil + }).(LookupObservabilityLogalertgroupResultOutput) +} + +// A collection of arguments for invoking getObservabilityLogalertgroup. +type LookupObservabilityLogalertgroupOutputArgs struct { + // Observability instance ID to which the log alert group is associated. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupObservabilityLogalertgroupOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityLogalertgroupArgs)(nil)).Elem() +} + +// A collection of values returned by getObservabilityLogalertgroup. +type LookupObservabilityLogalertgroupResultOutput struct{ *pulumi.OutputState } + +func (LookupObservabilityLogalertgroupResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityLogalertgroupResult)(nil)).Elem() +} + +func (o LookupObservabilityLogalertgroupResultOutput) ToLookupObservabilityLogalertgroupResultOutput() LookupObservabilityLogalertgroupResultOutput { + return o +} + +func (o LookupObservabilityLogalertgroupResultOutput) ToLookupObservabilityLogalertgroupResultOutputWithContext(ctx context.Context) LookupObservabilityLogalertgroupResultOutput { + return o +} + +func (o LookupObservabilityLogalertgroupResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Observability instance ID to which the log alert group is associated. +func (o LookupObservabilityLogalertgroupResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. +func (o LookupObservabilityLogalertgroupResultOutput) Interval() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) string { return v.Interval }).(pulumi.StringOutput) +} + +// The name of the log alert group. Is the identifier and must be unique in the group. +func (o LookupObservabilityLogalertgroupResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the log alert group is associated. +func (o LookupObservabilityLogalertgroupResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupObservabilityLogalertgroupResultOutput) Rules() GetObservabilityLogalertgroupRuleArrayOutput { + return o.ApplyT(func(v LookupObservabilityLogalertgroupResult) []GetObservabilityLogalertgroupRule { return v.Rules }).(GetObservabilityLogalertgroupRuleArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObservabilityLogalertgroupResultOutput{}) +} diff --git a/sdk/go/stackit/getObservabilityScrapeconfig.go b/sdk/go/stackit/getObservabilityScrapeconfig.go new file mode 100644 index 0000000..2cfa705 --- /dev/null +++ b/sdk/go/stackit/getObservabilityScrapeconfig.go @@ -0,0 +1,165 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability scrape config data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupObservabilityScrapeconfig(ctx *pulumi.Context, args *LookupObservabilityScrapeconfigArgs, opts ...pulumi.InvokeOption) (*LookupObservabilityScrapeconfigResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupObservabilityScrapeconfigResult + err := ctx.Invoke("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getObservabilityScrapeconfig. +type LookupObservabilityScrapeconfigArgs struct { + // Observability instance ID to which the scraping job is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the name of the scraping job + Name string `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getObservabilityScrapeconfig. +type LookupObservabilityScrapeconfigResult struct { + // A basic authentication block. + BasicAuth GetObservabilityScrapeconfigBasicAuth `pulumi:"basicAuth"` + Id string `pulumi:"id"` + // Observability instance ID to which the scraping job is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the job scraping url path. + MetricsPath string `pulumi:"metricsPath"` + // Specifies the name of the scraping job + Name string `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId string `pulumi:"projectId"` + // A SAML2 configuration block. + Saml2 GetObservabilityScrapeconfigSaml2 `pulumi:"saml2"` + // Specifies the scrape sample limit. + SampleLimit int `pulumi:"sampleLimit"` + // Specifies the http scheme. + Scheme string `pulumi:"scheme"` + // Specifies the scrape interval as duration string. + ScrapeInterval string `pulumi:"scrapeInterval"` + // Specifies the scrape timeout as duration string. + ScrapeTimeout string `pulumi:"scrapeTimeout"` + // The targets list (specified by the static config). + Targets []GetObservabilityScrapeconfigTarget `pulumi:"targets"` +} + +func LookupObservabilityScrapeconfigOutput(ctx *pulumi.Context, args LookupObservabilityScrapeconfigOutputArgs, opts ...pulumi.InvokeOption) LookupObservabilityScrapeconfigResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupObservabilityScrapeconfigResultOutput, error) { + args := v.(LookupObservabilityScrapeconfigArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", args, LookupObservabilityScrapeconfigResultOutput{}, options).(LookupObservabilityScrapeconfigResultOutput), nil + }).(LookupObservabilityScrapeconfigResultOutput) +} + +// A collection of arguments for invoking getObservabilityScrapeconfig. +type LookupObservabilityScrapeconfigOutputArgs struct { + // Observability instance ID to which the scraping job is associated. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // Specifies the name of the scraping job + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupObservabilityScrapeconfigOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityScrapeconfigArgs)(nil)).Elem() +} + +// A collection of values returned by getObservabilityScrapeconfig. +type LookupObservabilityScrapeconfigResultOutput struct{ *pulumi.OutputState } + +func (LookupObservabilityScrapeconfigResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupObservabilityScrapeconfigResult)(nil)).Elem() +} + +func (o LookupObservabilityScrapeconfigResultOutput) ToLookupObservabilityScrapeconfigResultOutput() LookupObservabilityScrapeconfigResultOutput { + return o +} + +func (o LookupObservabilityScrapeconfigResultOutput) ToLookupObservabilityScrapeconfigResultOutputWithContext(ctx context.Context) LookupObservabilityScrapeconfigResultOutput { + return o +} + +// A basic authentication block. +func (o LookupObservabilityScrapeconfigResultOutput) BasicAuth() GetObservabilityScrapeconfigBasicAuthOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) GetObservabilityScrapeconfigBasicAuth { + return v.BasicAuth + }).(GetObservabilityScrapeconfigBasicAuthOutput) +} + +func (o LookupObservabilityScrapeconfigResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Observability instance ID to which the scraping job is associated. +func (o LookupObservabilityScrapeconfigResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the job scraping url path. +func (o LookupObservabilityScrapeconfigResultOutput) MetricsPath() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.MetricsPath }).(pulumi.StringOutput) +} + +// Specifies the name of the scraping job +func (o LookupObservabilityScrapeconfigResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the scraping job is associated. +func (o LookupObservabilityScrapeconfigResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// A SAML2 configuration block. +func (o LookupObservabilityScrapeconfigResultOutput) Saml2() GetObservabilityScrapeconfigSaml2Output { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) GetObservabilityScrapeconfigSaml2 { return v.Saml2 }).(GetObservabilityScrapeconfigSaml2Output) +} + +// Specifies the scrape sample limit. +func (o LookupObservabilityScrapeconfigResultOutput) SampleLimit() pulumi.IntOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) int { return v.SampleLimit }).(pulumi.IntOutput) +} + +// Specifies the http scheme. +func (o LookupObservabilityScrapeconfigResultOutput) Scheme() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.Scheme }).(pulumi.StringOutput) +} + +// Specifies the scrape interval as duration string. +func (o LookupObservabilityScrapeconfigResultOutput) ScrapeInterval() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.ScrapeInterval }).(pulumi.StringOutput) +} + +// Specifies the scrape timeout as duration string. +func (o LookupObservabilityScrapeconfigResultOutput) ScrapeTimeout() pulumi.StringOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) string { return v.ScrapeTimeout }).(pulumi.StringOutput) +} + +// The targets list (specified by the static config). +func (o LookupObservabilityScrapeconfigResultOutput) Targets() GetObservabilityScrapeconfigTargetArrayOutput { + return o.ApplyT(func(v LookupObservabilityScrapeconfigResult) []GetObservabilityScrapeconfigTarget { return v.Targets }).(GetObservabilityScrapeconfigTargetArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupObservabilityScrapeconfigResultOutput{}) +} diff --git a/sdk/go/stackit/getOpensearchCredential.go b/sdk/go/stackit/getOpensearchCredential.go new file mode 100644 index 0000000..c742523 --- /dev/null +++ b/sdk/go/stackit/getOpensearchCredential.go @@ -0,0 +1,142 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupOpensearchCredential(ctx *pulumi.Context, args *LookupOpensearchCredentialArgs, opts ...pulumi.InvokeOption) (*LookupOpensearchCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOpensearchCredentialResult + err := ctx.Invoke("stackit:index/getOpensearchCredential:getOpensearchCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOpensearchCredential. +type LookupOpensearchCredentialArgs struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + // ID of the OpenSearch instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getOpensearchCredential. +type LookupOpensearchCredentialResult struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + Host string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + Id string `pulumi:"id"` + // ID of the OpenSearch instance. + InstanceId string `pulumi:"instanceId"` + Password string `pulumi:"password"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Scheme string `pulumi:"scheme"` + Uri string `pulumi:"uri"` + Username string `pulumi:"username"` +} + +func LookupOpensearchCredentialOutput(ctx *pulumi.Context, args LookupOpensearchCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupOpensearchCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOpensearchCredentialResultOutput, error) { + args := v.(LookupOpensearchCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getOpensearchCredential:getOpensearchCredential", args, LookupOpensearchCredentialResultOutput{}, options).(LookupOpensearchCredentialResultOutput), nil + }).(LookupOpensearchCredentialResultOutput) +} + +// A collection of arguments for invoking getOpensearchCredential. +type LookupOpensearchCredentialOutputArgs struct { + // The credential's ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // ID of the OpenSearch instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupOpensearchCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOpensearchCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getOpensearchCredential. +type LookupOpensearchCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupOpensearchCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOpensearchCredentialResult)(nil)).Elem() +} + +func (o LookupOpensearchCredentialResultOutput) ToLookupOpensearchCredentialResultOutput() LookupOpensearchCredentialResultOutput { + return o +} + +func (o LookupOpensearchCredentialResultOutput) ToLookupOpensearchCredentialResultOutputWithContext(ctx context.Context) LookupOpensearchCredentialResultOutput { + return o +} + +// The credential's ID. +func (o LookupOpensearchCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) []string { return v.Hosts }).(pulumi.StringArrayOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the OpenSearch instance. +func (o LookupOpensearchCredentialResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Password }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupOpensearchCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Scheme() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Scheme }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Uri }).(pulumi.StringOutput) +} + +func (o LookupOpensearchCredentialResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchCredentialResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOpensearchCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getOpensearchInstance.go b/sdk/go/stackit/getOpensearchInstance.go new file mode 100644 index 0000000..aa41c79 --- /dev/null +++ b/sdk/go/stackit/getOpensearchInstance.go @@ -0,0 +1,154 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupOpensearchInstance(ctx *pulumi.Context, args *LookupOpensearchInstanceArgs, opts ...pulumi.InvokeOption) (*LookupOpensearchInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOpensearchInstanceResult + err := ctx.Invoke("stackit:index/getOpensearchInstance:getOpensearchInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOpensearchInstance. +type LookupOpensearchInstanceArgs struct { + // ID of the OpenSearch instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getOpensearchInstance. +type LookupOpensearchInstanceResult struct { + CfGuid string `pulumi:"cfGuid"` + CfOrganizationGuid string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid string `pulumi:"cfSpaceGuid"` + DashboardUrl string `pulumi:"dashboardUrl"` + Id string `pulumi:"id"` + ImageUrl string `pulumi:"imageUrl"` + // ID of the OpenSearch instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + Parameters GetOpensearchInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId string `pulumi:"planId"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +func LookupOpensearchInstanceOutput(ctx *pulumi.Context, args LookupOpensearchInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupOpensearchInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOpensearchInstanceResultOutput, error) { + args := v.(LookupOpensearchInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getOpensearchInstance:getOpensearchInstance", args, LookupOpensearchInstanceResultOutput{}, options).(LookupOpensearchInstanceResultOutput), nil + }).(LookupOpensearchInstanceResultOutput) +} + +// A collection of arguments for invoking getOpensearchInstance. +type LookupOpensearchInstanceOutputArgs struct { + // ID of the OpenSearch instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupOpensearchInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOpensearchInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getOpensearchInstance. +type LookupOpensearchInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupOpensearchInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOpensearchInstanceResult)(nil)).Elem() +} + +func (o LookupOpensearchInstanceResultOutput) ToLookupOpensearchInstanceResultOutput() LookupOpensearchInstanceResultOutput { + return o +} + +func (o LookupOpensearchInstanceResultOutput) ToLookupOpensearchInstanceResultOutputWithContext(ctx context.Context) LookupOpensearchInstanceResultOutput { + return o +} + +func (o LookupOpensearchInstanceResultOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the OpenSearch instance. +func (o LookupOpensearchInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupOpensearchInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupOpensearchInstanceResultOutput) Parameters() GetOpensearchInstanceParametersOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) GetOpensearchInstanceParameters { return v.Parameters }).(GetOpensearchInstanceParametersOutput) +} + +// The selected plan ID. +func (o LookupOpensearchInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LookupOpensearchInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupOpensearchInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LookupOpensearchInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupOpensearchInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOpensearchInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getPostgresflexDatabase.go b/sdk/go/stackit/getPostgresflexDatabase.go new file mode 100644 index 0000000..929e430 --- /dev/null +++ b/sdk/go/stackit/getPostgresflexDatabase.go @@ -0,0 +1,132 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupPostgresflexDatabase(ctx *pulumi.Context, args *LookupPostgresflexDatabaseArgs, opts ...pulumi.InvokeOption) (*LookupPostgresflexDatabaseResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupPostgresflexDatabaseResult + err := ctx.Invoke("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getPostgresflexDatabase. +type LookupPostgresflexDatabaseArgs struct { + // Database ID. + DatabaseId string `pulumi:"databaseId"` + // ID of the Postgres Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getPostgresflexDatabase. +type LookupPostgresflexDatabaseResult struct { + // Database ID. + DatabaseId string `pulumi:"databaseId"` + Id string `pulumi:"id"` + // ID of the Postgres Flex instance. + InstanceId string `pulumi:"instanceId"` + // Database name. + Name string `pulumi:"name"` + // Username of the database owner. + Owner string `pulumi:"owner"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +func LookupPostgresflexDatabaseOutput(ctx *pulumi.Context, args LookupPostgresflexDatabaseOutputArgs, opts ...pulumi.InvokeOption) LookupPostgresflexDatabaseResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupPostgresflexDatabaseResultOutput, error) { + args := v.(LookupPostgresflexDatabaseArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", args, LookupPostgresflexDatabaseResultOutput{}, options).(LookupPostgresflexDatabaseResultOutput), nil + }).(LookupPostgresflexDatabaseResultOutput) +} + +// A collection of arguments for invoking getPostgresflexDatabase. +type LookupPostgresflexDatabaseOutputArgs struct { + // Database ID. + DatabaseId pulumi.StringInput `pulumi:"databaseId"` + // ID of the Postgres Flex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupPostgresflexDatabaseOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexDatabaseArgs)(nil)).Elem() +} + +// A collection of values returned by getPostgresflexDatabase. +type LookupPostgresflexDatabaseResultOutput struct{ *pulumi.OutputState } + +func (LookupPostgresflexDatabaseResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexDatabaseResult)(nil)).Elem() +} + +func (o LookupPostgresflexDatabaseResultOutput) ToLookupPostgresflexDatabaseResultOutput() LookupPostgresflexDatabaseResultOutput { + return o +} + +func (o LookupPostgresflexDatabaseResultOutput) ToLookupPostgresflexDatabaseResultOutputWithContext(ctx context.Context) LookupPostgresflexDatabaseResultOutput { + return o +} + +// Database ID. +func (o LookupPostgresflexDatabaseResultOutput) DatabaseId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.DatabaseId }).(pulumi.StringOutput) +} + +func (o LookupPostgresflexDatabaseResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the Postgres Flex instance. +func (o LookupPostgresflexDatabaseResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Database name. +func (o LookupPostgresflexDatabaseResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Username of the database owner. +func (o LookupPostgresflexDatabaseResultOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.Owner }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupPostgresflexDatabaseResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupPostgresflexDatabaseResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupPostgresflexDatabaseResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupPostgresflexDatabaseResultOutput{}) +} diff --git a/sdk/go/stackit/getPostgresflexInstance.go b/sdk/go/stackit/getPostgresflexInstance.go new file mode 100644 index 0000000..e9476b1 --- /dev/null +++ b/sdk/go/stackit/getPostgresflexInstance.go @@ -0,0 +1,146 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupPostgresflexInstance(ctx *pulumi.Context, args *LookupPostgresflexInstanceArgs, opts ...pulumi.InvokeOption) (*LookupPostgresflexInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupPostgresflexInstanceResult + err := ctx.Invoke("stackit:index/getPostgresflexInstance:getPostgresflexInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getPostgresflexInstance. +type LookupPostgresflexInstanceArgs struct { + // ID of the PostgresFlex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getPostgresflexInstance. +type LookupPostgresflexInstanceResult struct { + // The Access Control List (ACL) for the PostgresFlex instance. + Acls []string `pulumi:"acls"` + BackupSchedule string `pulumi:"backupSchedule"` + Flavor GetPostgresflexInstanceFlavor `pulumi:"flavor"` + Id string `pulumi:"id"` + // ID of the PostgresFlex instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Replicas int `pulumi:"replicas"` + Storage GetPostgresflexInstanceStorage `pulumi:"storage"` + Version string `pulumi:"version"` +} + +func LookupPostgresflexInstanceOutput(ctx *pulumi.Context, args LookupPostgresflexInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupPostgresflexInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupPostgresflexInstanceResultOutput, error) { + args := v.(LookupPostgresflexInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getPostgresflexInstance:getPostgresflexInstance", args, LookupPostgresflexInstanceResultOutput{}, options).(LookupPostgresflexInstanceResultOutput), nil + }).(LookupPostgresflexInstanceResultOutput) +} + +// A collection of arguments for invoking getPostgresflexInstance. +type LookupPostgresflexInstanceOutputArgs struct { + // ID of the PostgresFlex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupPostgresflexInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getPostgresflexInstance. +type LookupPostgresflexInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupPostgresflexInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexInstanceResult)(nil)).Elem() +} + +func (o LookupPostgresflexInstanceResultOutput) ToLookupPostgresflexInstanceResultOutput() LookupPostgresflexInstanceResultOutput { + return o +} + +func (o LookupPostgresflexInstanceResultOutput) ToLookupPostgresflexInstanceResultOutputWithContext(ctx context.Context) LookupPostgresflexInstanceResultOutput { + return o +} + +// The Access Control List (ACL) for the PostgresFlex instance. +func (o LookupPostgresflexInstanceResultOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) Flavor() GetPostgresflexInstanceFlavorOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) GetPostgresflexInstanceFlavor { return v.Flavor }).(GetPostgresflexInstanceFlavorOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the PostgresFlex instance. +func (o LookupPostgresflexInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupPostgresflexInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupPostgresflexInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupPostgresflexInstanceResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) int { return v.Replicas }).(pulumi.IntOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) Storage() GetPostgresflexInstanceStorageOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) GetPostgresflexInstanceStorage { return v.Storage }).(GetPostgresflexInstanceStorageOutput) +} + +func (o LookupPostgresflexInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupPostgresflexInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getPostgresflexUser.go b/sdk/go/stackit/getPostgresflexUser.go new file mode 100644 index 0000000..3eb3666 --- /dev/null +++ b/sdk/go/stackit/getPostgresflexUser.go @@ -0,0 +1,138 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupPostgresflexUser(ctx *pulumi.Context, args *LookupPostgresflexUserArgs, opts ...pulumi.InvokeOption) (*LookupPostgresflexUserResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupPostgresflexUserResult + err := ctx.Invoke("stackit:index/getPostgresflexUser:getPostgresflexUser", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getPostgresflexUser. +type LookupPostgresflexUserArgs struct { + // ID of the PostgresFlex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // User ID. + UserId string `pulumi:"userId"` +} + +// A collection of values returned by getPostgresflexUser. +type LookupPostgresflexUserResult struct { + Host string `pulumi:"host"` + Id string `pulumi:"id"` + // ID of the PostgresFlex instance. + InstanceId string `pulumi:"instanceId"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Roles []string `pulumi:"roles"` + // User ID. + UserId string `pulumi:"userId"` + Username string `pulumi:"username"` +} + +func LookupPostgresflexUserOutput(ctx *pulumi.Context, args LookupPostgresflexUserOutputArgs, opts ...pulumi.InvokeOption) LookupPostgresflexUserResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupPostgresflexUserResultOutput, error) { + args := v.(LookupPostgresflexUserArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getPostgresflexUser:getPostgresflexUser", args, LookupPostgresflexUserResultOutput{}, options).(LookupPostgresflexUserResultOutput), nil + }).(LookupPostgresflexUserResultOutput) +} + +// A collection of arguments for invoking getPostgresflexUser. +type LookupPostgresflexUserOutputArgs struct { + // ID of the PostgresFlex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // User ID. + UserId pulumi.StringInput `pulumi:"userId"` +} + +func (LookupPostgresflexUserOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexUserArgs)(nil)).Elem() +} + +// A collection of values returned by getPostgresflexUser. +type LookupPostgresflexUserResultOutput struct{ *pulumi.OutputState } + +func (LookupPostgresflexUserResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPostgresflexUserResult)(nil)).Elem() +} + +func (o LookupPostgresflexUserResultOutput) ToLookupPostgresflexUserResultOutput() LookupPostgresflexUserResultOutput { + return o +} + +func (o LookupPostgresflexUserResultOutput) ToLookupPostgresflexUserResultOutputWithContext(ctx context.Context) LookupPostgresflexUserResultOutput { + return o +} + +func (o LookupPostgresflexUserResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupPostgresflexUserResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the PostgresFlex instance. +func (o LookupPostgresflexUserResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupPostgresflexUserResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupPostgresflexUserResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupPostgresflexUserResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func (o LookupPostgresflexUserResultOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) []string { return v.Roles }).(pulumi.StringArrayOutput) +} + +// User ID. +func (o LookupPostgresflexUserResultOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.UserId }).(pulumi.StringOutput) +} + +func (o LookupPostgresflexUserResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupPostgresflexUserResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupPostgresflexUserResultOutput{}) +} diff --git a/sdk/go/stackit/getPublicIp.go b/sdk/go/stackit/getPublicIp.go new file mode 100644 index 0000000..48b8379 --- /dev/null +++ b/sdk/go/stackit/getPublicIp.go @@ -0,0 +1,117 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Public IP resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupPublicIp(ctx *pulumi.Context, args *LookupPublicIpArgs, opts ...pulumi.InvokeOption) (*LookupPublicIpResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupPublicIpResult + err := ctx.Invoke("stackit:index/getPublicIp:getPublicIp", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getPublicIp. +type LookupPublicIpArgs struct { + // STACKIT project ID to which the public IP is associated. + ProjectId string `pulumi:"projectId"` + // The public IP ID. + PublicIpId string `pulumi:"publicIpId"` +} + +// A collection of values returned by getPublicIp. +type LookupPublicIpResult struct { + Id string `pulumi:"id"` + // The IP address. + Ip string `pulumi:"ip"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // Associates the public IP with a network interface or a virtual IP (ID). + NetworkInterfaceId string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId string `pulumi:"projectId"` + // The public IP ID. + PublicIpId string `pulumi:"publicIpId"` +} + +func LookupPublicIpOutput(ctx *pulumi.Context, args LookupPublicIpOutputArgs, opts ...pulumi.InvokeOption) LookupPublicIpResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupPublicIpResultOutput, error) { + args := v.(LookupPublicIpArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getPublicIp:getPublicIp", args, LookupPublicIpResultOutput{}, options).(LookupPublicIpResultOutput), nil + }).(LookupPublicIpResultOutput) +} + +// A collection of arguments for invoking getPublicIp. +type LookupPublicIpOutputArgs struct { + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The public IP ID. + PublicIpId pulumi.StringInput `pulumi:"publicIpId"` +} + +func (LookupPublicIpOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPublicIpArgs)(nil)).Elem() +} + +// A collection of values returned by getPublicIp. +type LookupPublicIpResultOutput struct{ *pulumi.OutputState } + +func (LookupPublicIpResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupPublicIpResult)(nil)).Elem() +} + +func (o LookupPublicIpResultOutput) ToLookupPublicIpResultOutput() LookupPublicIpResultOutput { + return o +} + +func (o LookupPublicIpResultOutput) ToLookupPublicIpResultOutputWithContext(ctx context.Context) LookupPublicIpResultOutput { + return o +} + +func (o LookupPublicIpResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupPublicIpResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The IP address. +func (o LookupPublicIpResultOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v LookupPublicIpResult) string { return v.Ip }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupPublicIpResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupPublicIpResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// Associates the public IP with a network interface or a virtual IP (ID). +func (o LookupPublicIpResultOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPublicIpResult) string { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the public IP is associated. +func (o LookupPublicIpResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPublicIpResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The public IP ID. +func (o LookupPublicIpResultOutput) PublicIpId() pulumi.StringOutput { + return o.ApplyT(func(v LookupPublicIpResult) string { return v.PublicIpId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupPublicIpResultOutput{}) +} diff --git a/sdk/go/stackit/getPublicIpRanges.go b/sdk/go/stackit/getPublicIpRanges.go new file mode 100644 index 0000000..f94b8a1 --- /dev/null +++ b/sdk/go/stackit/getPublicIpRanges.go @@ -0,0 +1,67 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// A list of all public IP ranges that STACKIT uses. +// +// ## Example Usage +func GetPublicIpRanges(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetPublicIpRangesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetPublicIpRangesResult + err := ctx.Invoke("stackit:index/getPublicIpRanges:getPublicIpRanges", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getPublicIpRanges. +type GetPublicIpRangesResult struct { + Id string `pulumi:"id"` + // A list of all public IP ranges. + PublicIpRanges []GetPublicIpRangesPublicIpRange `pulumi:"publicIpRanges"` +} + +func GetPublicIpRangesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetPublicIpRangesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetPublicIpRangesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getPublicIpRanges:getPublicIpRanges", nil, GetPublicIpRangesResultOutput{}, options).(GetPublicIpRangesResultOutput), nil + }).(GetPublicIpRangesResultOutput) +} + +// A collection of values returned by getPublicIpRanges. +type GetPublicIpRangesResultOutput struct{ *pulumi.OutputState } + +func (GetPublicIpRangesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetPublicIpRangesResult)(nil)).Elem() +} + +func (o GetPublicIpRangesResultOutput) ToGetPublicIpRangesResultOutput() GetPublicIpRangesResultOutput { + return o +} + +func (o GetPublicIpRangesResultOutput) ToGetPublicIpRangesResultOutputWithContext(ctx context.Context) GetPublicIpRangesResultOutput { + return o +} + +func (o GetPublicIpRangesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetPublicIpRangesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// A list of all public IP ranges. +func (o GetPublicIpRangesResultOutput) PublicIpRanges() GetPublicIpRangesPublicIpRangeArrayOutput { + return o.ApplyT(func(v GetPublicIpRangesResult) []GetPublicIpRangesPublicIpRange { return v.PublicIpRanges }).(GetPublicIpRangesPublicIpRangeArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetPublicIpRangesResultOutput{}) +} diff --git a/sdk/go/stackit/getRabbitmqCredential.go b/sdk/go/stackit/getRabbitmqCredential.go new file mode 100644 index 0000000..51cb950 --- /dev/null +++ b/sdk/go/stackit/getRabbitmqCredential.go @@ -0,0 +1,157 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupRabbitmqCredential(ctx *pulumi.Context, args *LookupRabbitmqCredentialArgs, opts ...pulumi.InvokeOption) (*LookupRabbitmqCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRabbitmqCredentialResult + err := ctx.Invoke("stackit:index/getRabbitmqCredential:getRabbitmqCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRabbitmqCredential. +type LookupRabbitmqCredentialArgs struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + // ID of the RabbitMQ instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getRabbitmqCredential. +type LookupRabbitmqCredentialResult struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + Host string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + HttpApiUri string `pulumi:"httpApiUri"` + HttpApiUris []string `pulumi:"httpApiUris"` + Id string `pulumi:"id"` + // ID of the RabbitMQ instance. + InstanceId string `pulumi:"instanceId"` + Management string `pulumi:"management"` + Password string `pulumi:"password"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Uri string `pulumi:"uri"` + Uris []string `pulumi:"uris"` + Username string `pulumi:"username"` +} + +func LookupRabbitmqCredentialOutput(ctx *pulumi.Context, args LookupRabbitmqCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupRabbitmqCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRabbitmqCredentialResultOutput, error) { + args := v.(LookupRabbitmqCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getRabbitmqCredential:getRabbitmqCredential", args, LookupRabbitmqCredentialResultOutput{}, options).(LookupRabbitmqCredentialResultOutput), nil + }).(LookupRabbitmqCredentialResultOutput) +} + +// A collection of arguments for invoking getRabbitmqCredential. +type LookupRabbitmqCredentialOutputArgs struct { + // The credential's ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // ID of the RabbitMQ instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupRabbitmqCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRabbitmqCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getRabbitmqCredential. +type LookupRabbitmqCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupRabbitmqCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRabbitmqCredentialResult)(nil)).Elem() +} + +func (o LookupRabbitmqCredentialResultOutput) ToLookupRabbitmqCredentialResultOutput() LookupRabbitmqCredentialResultOutput { + return o +} + +func (o LookupRabbitmqCredentialResultOutput) ToLookupRabbitmqCredentialResultOutputWithContext(ctx context.Context) LookupRabbitmqCredentialResultOutput { + return o +} + +// The credential's ID. +func (o LookupRabbitmqCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) []string { return v.Hosts }).(pulumi.StringArrayOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) HttpApiUri() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.HttpApiUri }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) HttpApiUris() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) []string { return v.HttpApiUris }).(pulumi.StringArrayOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the RabbitMQ instance. +func (o LookupRabbitmqCredentialResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Management() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Management }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Password }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupRabbitmqCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Uri }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Uris() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) []string { return v.Uris }).(pulumi.StringArrayOutput) +} + +func (o LookupRabbitmqCredentialResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqCredentialResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRabbitmqCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getRabbitmqInstance.go b/sdk/go/stackit/getRabbitmqInstance.go new file mode 100644 index 0000000..2db2716 --- /dev/null +++ b/sdk/go/stackit/getRabbitmqInstance.go @@ -0,0 +1,154 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupRabbitmqInstance(ctx *pulumi.Context, args *LookupRabbitmqInstanceArgs, opts ...pulumi.InvokeOption) (*LookupRabbitmqInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRabbitmqInstanceResult + err := ctx.Invoke("stackit:index/getRabbitmqInstance:getRabbitmqInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRabbitmqInstance. +type LookupRabbitmqInstanceArgs struct { + // ID of the RabbitMQ instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getRabbitmqInstance. +type LookupRabbitmqInstanceResult struct { + CfGuid string `pulumi:"cfGuid"` + CfOrganizationGuid string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid string `pulumi:"cfSpaceGuid"` + DashboardUrl string `pulumi:"dashboardUrl"` + Id string `pulumi:"id"` + ImageUrl string `pulumi:"imageUrl"` + // ID of the RabbitMQ instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + Parameters GetRabbitmqInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId string `pulumi:"planId"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +func LookupRabbitmqInstanceOutput(ctx *pulumi.Context, args LookupRabbitmqInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupRabbitmqInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRabbitmqInstanceResultOutput, error) { + args := v.(LookupRabbitmqInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getRabbitmqInstance:getRabbitmqInstance", args, LookupRabbitmqInstanceResultOutput{}, options).(LookupRabbitmqInstanceResultOutput), nil + }).(LookupRabbitmqInstanceResultOutput) +} + +// A collection of arguments for invoking getRabbitmqInstance. +type LookupRabbitmqInstanceOutputArgs struct { + // ID of the RabbitMQ instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupRabbitmqInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRabbitmqInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getRabbitmqInstance. +type LookupRabbitmqInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupRabbitmqInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRabbitmqInstanceResult)(nil)).Elem() +} + +func (o LookupRabbitmqInstanceResultOutput) ToLookupRabbitmqInstanceResultOutput() LookupRabbitmqInstanceResultOutput { + return o +} + +func (o LookupRabbitmqInstanceResultOutput) ToLookupRabbitmqInstanceResultOutputWithContext(ctx context.Context) LookupRabbitmqInstanceResultOutput { + return o +} + +func (o LookupRabbitmqInstanceResultOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the RabbitMQ instance. +func (o LookupRabbitmqInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupRabbitmqInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupRabbitmqInstanceResultOutput) Parameters() GetRabbitmqInstanceParametersOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) GetRabbitmqInstanceParameters { return v.Parameters }).(GetRabbitmqInstanceParametersOutput) +} + +// The selected plan ID. +func (o LookupRabbitmqInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LookupRabbitmqInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupRabbitmqInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LookupRabbitmqInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupRabbitmqInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRabbitmqInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getRedisCredential.go b/sdk/go/stackit/getRedisCredential.go new file mode 100644 index 0000000..e4a6412 --- /dev/null +++ b/sdk/go/stackit/getRedisCredential.go @@ -0,0 +1,144 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Redis credential data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupRedisCredential(ctx *pulumi.Context, args *LookupRedisCredentialArgs, opts ...pulumi.InvokeOption) (*LookupRedisCredentialResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRedisCredentialResult + err := ctx.Invoke("stackit:index/getRedisCredential:getRedisCredential", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRedisCredential. +type LookupRedisCredentialArgs struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + // ID of the Redis instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getRedisCredential. +type LookupRedisCredentialResult struct { + // The credential's ID. + CredentialId string `pulumi:"credentialId"` + Host string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + Id string `pulumi:"id"` + // ID of the Redis instance. + InstanceId string `pulumi:"instanceId"` + LoadBalancedHost string `pulumi:"loadBalancedHost"` + Password string `pulumi:"password"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // Connection URI. + Uri string `pulumi:"uri"` + Username string `pulumi:"username"` +} + +func LookupRedisCredentialOutput(ctx *pulumi.Context, args LookupRedisCredentialOutputArgs, opts ...pulumi.InvokeOption) LookupRedisCredentialResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRedisCredentialResultOutput, error) { + args := v.(LookupRedisCredentialArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getRedisCredential:getRedisCredential", args, LookupRedisCredentialResultOutput{}, options).(LookupRedisCredentialResultOutput), nil + }).(LookupRedisCredentialResultOutput) +} + +// A collection of arguments for invoking getRedisCredential. +type LookupRedisCredentialOutputArgs struct { + // The credential's ID. + CredentialId pulumi.StringInput `pulumi:"credentialId"` + // ID of the Redis instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupRedisCredentialOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRedisCredentialArgs)(nil)).Elem() +} + +// A collection of values returned by getRedisCredential. +type LookupRedisCredentialResultOutput struct{ *pulumi.OutputState } + +func (LookupRedisCredentialResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRedisCredentialResult)(nil)).Elem() +} + +func (o LookupRedisCredentialResultOutput) ToLookupRedisCredentialResultOutput() LookupRedisCredentialResultOutput { + return o +} + +func (o LookupRedisCredentialResultOutput) ToLookupRedisCredentialResultOutputWithContext(ctx context.Context) LookupRedisCredentialResultOutput { + return o +} + +// The credential's ID. +func (o LookupRedisCredentialResultOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) []string { return v.Hosts }).(pulumi.StringArrayOutput) +} + +func (o LookupRedisCredentialResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the Redis instance. +func (o LookupRedisCredentialResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) LoadBalancedHost() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.LoadBalancedHost }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.Password }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupRedisCredentialResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// Connection URI. +func (o LookupRedisCredentialResultOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.Uri }).(pulumi.StringOutput) +} + +func (o LookupRedisCredentialResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisCredentialResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRedisCredentialResultOutput{}) +} diff --git a/sdk/go/stackit/getRedisInstance.go b/sdk/go/stackit/getRedisInstance.go new file mode 100644 index 0000000..4f3b936 --- /dev/null +++ b/sdk/go/stackit/getRedisInstance.go @@ -0,0 +1,154 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Redis instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupRedisInstance(ctx *pulumi.Context, args *LookupRedisInstanceArgs, opts ...pulumi.InvokeOption) (*LookupRedisInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRedisInstanceResult + err := ctx.Invoke("stackit:index/getRedisInstance:getRedisInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRedisInstance. +type LookupRedisInstanceArgs struct { + // ID of the Redis instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getRedisInstance. +type LookupRedisInstanceResult struct { + CfGuid string `pulumi:"cfGuid"` + CfOrganizationGuid string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid string `pulumi:"cfSpaceGuid"` + DashboardUrl string `pulumi:"dashboardUrl"` + Id string `pulumi:"id"` + ImageUrl string `pulumi:"imageUrl"` + // ID of the Redis instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + Parameters GetRedisInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId string `pulumi:"planId"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +func LookupRedisInstanceOutput(ctx *pulumi.Context, args LookupRedisInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupRedisInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRedisInstanceResultOutput, error) { + args := v.(LookupRedisInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getRedisInstance:getRedisInstance", args, LookupRedisInstanceResultOutput{}, options).(LookupRedisInstanceResultOutput), nil + }).(LookupRedisInstanceResultOutput) +} + +// A collection of arguments for invoking getRedisInstance. +type LookupRedisInstanceOutputArgs struct { + // ID of the Redis instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupRedisInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRedisInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getRedisInstance. +type LookupRedisInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupRedisInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRedisInstanceResult)(nil)).Elem() +} + +func (o LookupRedisInstanceResultOutput) ToLookupRedisInstanceResultOutput() LookupRedisInstanceResultOutput { + return o +} + +func (o LookupRedisInstanceResultOutput) ToLookupRedisInstanceResultOutputWithContext(ctx context.Context) LookupRedisInstanceResultOutput { + return o +} + +func (o LookupRedisInstanceResultOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the Redis instance. +func (o LookupRedisInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupRedisInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupRedisInstanceResultOutput) Parameters() GetRedisInstanceParametersOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) GetRedisInstanceParameters { return v.Parameters }).(GetRedisInstanceParametersOutput) +} + +// The selected plan ID. +func (o LookupRedisInstanceResultOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LookupRedisInstanceResultOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupRedisInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LookupRedisInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupRedisInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRedisInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getResourcemanagerProject.go b/sdk/go/stackit/getResourcemanagerProject.go new file mode 100644 index 0000000..df4f72c --- /dev/null +++ b/sdk/go/stackit/getResourcemanagerProject.go @@ -0,0 +1,117 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Resource Manager project data source schema. To identify the project, you need to provider either projectId or container_id. If you provide both, projectId will be used. +// +// ## Example Usage +func LookupResourcemanagerProject(ctx *pulumi.Context, args *LookupResourcemanagerProjectArgs, opts ...pulumi.InvokeOption) (*LookupResourcemanagerProjectResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupResourcemanagerProjectResult + err := ctx.Invoke("stackit:index/getResourcemanagerProject:getResourcemanagerProject", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getResourcemanagerProject. +type LookupResourcemanagerProjectArgs struct { + // Project container ID. Globally unique, user-friendly identifier. + ContainerId *string `pulumi:"containerId"` + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId *string `pulumi:"projectId"` +} + +// A collection of values returned by getResourcemanagerProject. +type LookupResourcemanagerProjectResult struct { + // Project container ID. Globally unique, user-friendly identifier. + ContainerId *string `pulumi:"containerId"` + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64} + Labels map[string]string `pulumi:"labels"` + // Project name. + Name string `pulumi:"name"` + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId string `pulumi:"parentContainerId"` + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId *string `pulumi:"projectId"` +} + +func LookupResourcemanagerProjectOutput(ctx *pulumi.Context, args LookupResourcemanagerProjectOutputArgs, opts ...pulumi.InvokeOption) LookupResourcemanagerProjectResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupResourcemanagerProjectResultOutput, error) { + args := v.(LookupResourcemanagerProjectArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getResourcemanagerProject:getResourcemanagerProject", args, LookupResourcemanagerProjectResultOutput{}, options).(LookupResourcemanagerProjectResultOutput), nil + }).(LookupResourcemanagerProjectResultOutput) +} + +// A collection of arguments for invoking getResourcemanagerProject. +type LookupResourcemanagerProjectOutputArgs struct { + // Project container ID. Globally unique, user-friendly identifier. + ContainerId pulumi.StringPtrInput `pulumi:"containerId"` + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId pulumi.StringPtrInput `pulumi:"projectId"` +} + +func (LookupResourcemanagerProjectOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupResourcemanagerProjectArgs)(nil)).Elem() +} + +// A collection of values returned by getResourcemanagerProject. +type LookupResourcemanagerProjectResultOutput struct{ *pulumi.OutputState } + +func (LookupResourcemanagerProjectResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupResourcemanagerProjectResult)(nil)).Elem() +} + +func (o LookupResourcemanagerProjectResultOutput) ToLookupResourcemanagerProjectResultOutput() LookupResourcemanagerProjectResultOutput { + return o +} + +func (o LookupResourcemanagerProjectResultOutput) ToLookupResourcemanagerProjectResultOutputWithContext(ctx context.Context) LookupResourcemanagerProjectResultOutput { + return o +} + +// Project container ID. Globally unique, user-friendly identifier. +func (o LookupResourcemanagerProjectResultOutput) ContainerId() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) *string { return v.ContainerId }).(pulumi.StringPtrOutput) +} + +func (o LookupResourcemanagerProjectResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64} +func (o LookupResourcemanagerProjectResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// Project name. +func (o LookupResourcemanagerProjectResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Parent resource identifier. Both container ID (user-friendly) and UUID are supported +func (o LookupResourcemanagerProjectResultOutput) ParentContainerId() pulumi.StringOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) string { return v.ParentContainerId }).(pulumi.StringOutput) +} + +// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. +func (o LookupResourcemanagerProjectResultOutput) ProjectId() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupResourcemanagerProjectResult) *string { return v.ProjectId }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupResourcemanagerProjectResultOutput{}) +} diff --git a/sdk/go/stackit/getSecretsmanagerInstance.go b/sdk/go/stackit/getSecretsmanagerInstance.go new file mode 100644 index 0000000..bd12657 --- /dev/null +++ b/sdk/go/stackit/getSecretsmanagerInstance.go @@ -0,0 +1,110 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSecretsmanagerInstance(ctx *pulumi.Context, args *LookupSecretsmanagerInstanceArgs, opts ...pulumi.InvokeOption) (*LookupSecretsmanagerInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSecretsmanagerInstanceResult + err := ctx.Invoke("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSecretsmanagerInstance. +type LookupSecretsmanagerInstanceArgs struct { + // ID of the Secrets Manager instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getSecretsmanagerInstance. +type LookupSecretsmanagerInstanceResult struct { + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls []string `pulumi:"acls"` + Id string `pulumi:"id"` + // ID of the Secrets Manager instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +func LookupSecretsmanagerInstanceOutput(ctx *pulumi.Context, args LookupSecretsmanagerInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupSecretsmanagerInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSecretsmanagerInstanceResultOutput, error) { + args := v.(LookupSecretsmanagerInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", args, LookupSecretsmanagerInstanceResultOutput{}, options).(LookupSecretsmanagerInstanceResultOutput), nil + }).(LookupSecretsmanagerInstanceResultOutput) +} + +// A collection of arguments for invoking getSecretsmanagerInstance. +type LookupSecretsmanagerInstanceOutputArgs struct { + // ID of the Secrets Manager instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupSecretsmanagerInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecretsmanagerInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getSecretsmanagerInstance. +type LookupSecretsmanagerInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupSecretsmanagerInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecretsmanagerInstanceResult)(nil)).Elem() +} + +func (o LookupSecretsmanagerInstanceResultOutput) ToLookupSecretsmanagerInstanceResultOutput() LookupSecretsmanagerInstanceResultOutput { + return o +} + +func (o LookupSecretsmanagerInstanceResultOutput) ToLookupSecretsmanagerInstanceResultOutputWithContext(ctx context.Context) LookupSecretsmanagerInstanceResultOutput { + return o +} + +// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation +func (o LookupSecretsmanagerInstanceResultOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupSecretsmanagerInstanceResult) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +func (o LookupSecretsmanagerInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the Secrets Manager instance. +func (o LookupSecretsmanagerInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupSecretsmanagerInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupSecretsmanagerInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSecretsmanagerInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getSecretsmanagerUser.go b/sdk/go/stackit/getSecretsmanagerUser.go new file mode 100644 index 0000000..791d394 --- /dev/null +++ b/sdk/go/stackit/getSecretsmanagerUser.go @@ -0,0 +1,128 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSecretsmanagerUser(ctx *pulumi.Context, args *LookupSecretsmanagerUserArgs, opts ...pulumi.InvokeOption) (*LookupSecretsmanagerUserResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSecretsmanagerUserResult + err := ctx.Invoke("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSecretsmanagerUser. +type LookupSecretsmanagerUserArgs struct { + // ID of the Secrets Manager instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The user's ID. + UserId string `pulumi:"userId"` +} + +// A collection of values returned by getSecretsmanagerUser. +type LookupSecretsmanagerUserResult struct { + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description string `pulumi:"description"` + Id string `pulumi:"id"` + // ID of the Secrets Manager instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The user's ID. + UserId string `pulumi:"userId"` + // An auto-generated user name. + Username string `pulumi:"username"` + // If true, the user has writeaccess to the secrets engine. + WriteEnabled bool `pulumi:"writeEnabled"` +} + +func LookupSecretsmanagerUserOutput(ctx *pulumi.Context, args LookupSecretsmanagerUserOutputArgs, opts ...pulumi.InvokeOption) LookupSecretsmanagerUserResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSecretsmanagerUserResultOutput, error) { + args := v.(LookupSecretsmanagerUserArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", args, LookupSecretsmanagerUserResultOutput{}, options).(LookupSecretsmanagerUserResultOutput), nil + }).(LookupSecretsmanagerUserResultOutput) +} + +// A collection of arguments for invoking getSecretsmanagerUser. +type LookupSecretsmanagerUserOutputArgs struct { + // ID of the Secrets Manager instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The user's ID. + UserId pulumi.StringInput `pulumi:"userId"` +} + +func (LookupSecretsmanagerUserOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecretsmanagerUserArgs)(nil)).Elem() +} + +// A collection of values returned by getSecretsmanagerUser. +type LookupSecretsmanagerUserResultOutput struct{ *pulumi.OutputState } + +func (LookupSecretsmanagerUserResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecretsmanagerUserResult)(nil)).Elem() +} + +func (o LookupSecretsmanagerUserResultOutput) ToLookupSecretsmanagerUserResultOutput() LookupSecretsmanagerUserResultOutput { + return o +} + +func (o LookupSecretsmanagerUserResultOutput) ToLookupSecretsmanagerUserResultOutputWithContext(ctx context.Context) LookupSecretsmanagerUserResultOutput { + return o +} + +// A user chosen description to differentiate between multiple users. Can't be changed after creation. +func (o LookupSecretsmanagerUserResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.Description }).(pulumi.StringOutput) +} + +func (o LookupSecretsmanagerUserResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the Secrets Manager instance. +func (o LookupSecretsmanagerUserResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LookupSecretsmanagerUserResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The user's ID. +func (o LookupSecretsmanagerUserResultOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.UserId }).(pulumi.StringOutput) +} + +// An auto-generated user name. +func (o LookupSecretsmanagerUserResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) string { return v.Username }).(pulumi.StringOutput) +} + +// If true, the user has writeaccess to the secrets engine. +func (o LookupSecretsmanagerUserResultOutput) WriteEnabled() pulumi.BoolOutput { + return o.ApplyT(func(v LookupSecretsmanagerUserResult) bool { return v.WriteEnabled }).(pulumi.BoolOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSecretsmanagerUserResultOutput{}) +} diff --git a/sdk/go/stackit/getSecurityGroup.go b/sdk/go/stackit/getSecurityGroup.go new file mode 100644 index 0000000..89b99d2 --- /dev/null +++ b/sdk/go/stackit/getSecurityGroup.go @@ -0,0 +1,124 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Security group datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSecurityGroup(ctx *pulumi.Context, args *LookupSecurityGroupArgs, opts ...pulumi.InvokeOption) (*LookupSecurityGroupResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSecurityGroupResult + err := ctx.Invoke("stackit:index/getSecurityGroup:getSecurityGroup", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSecurityGroup. +type LookupSecurityGroupArgs struct { + // STACKIT project ID to which the security group is associated. + ProjectId string `pulumi:"projectId"` + // The security group ID. + SecurityGroupId string `pulumi:"securityGroupId"` +} + +// A collection of values returned by getSecurityGroup. +type LookupSecurityGroupResult struct { + // The description of the security group. + Description string `pulumi:"description"` + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the security group. + Name string `pulumi:"name"` + // STACKIT project ID to which the security group is associated. + ProjectId string `pulumi:"projectId"` + // The security group ID. + SecurityGroupId string `pulumi:"securityGroupId"` + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful bool `pulumi:"stateful"` +} + +func LookupSecurityGroupOutput(ctx *pulumi.Context, args LookupSecurityGroupOutputArgs, opts ...pulumi.InvokeOption) LookupSecurityGroupResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSecurityGroupResultOutput, error) { + args := v.(LookupSecurityGroupArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSecurityGroup:getSecurityGroup", args, LookupSecurityGroupResultOutput{}, options).(LookupSecurityGroupResultOutput), nil + }).(LookupSecurityGroupResultOutput) +} + +// A collection of arguments for invoking getSecurityGroup. +type LookupSecurityGroupOutputArgs struct { + // STACKIT project ID to which the security group is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The security group ID. + SecurityGroupId pulumi.StringInput `pulumi:"securityGroupId"` +} + +func (LookupSecurityGroupOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecurityGroupArgs)(nil)).Elem() +} + +// A collection of values returned by getSecurityGroup. +type LookupSecurityGroupResultOutput struct{ *pulumi.OutputState } + +func (LookupSecurityGroupResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecurityGroupResult)(nil)).Elem() +} + +func (o LookupSecurityGroupResultOutput) ToLookupSecurityGroupResultOutput() LookupSecurityGroupResultOutput { + return o +} + +func (o LookupSecurityGroupResultOutput) ToLookupSecurityGroupResultOutputWithContext(ctx context.Context) LookupSecurityGroupResultOutput { + return o +} + +// The description of the security group. +func (o LookupSecurityGroupResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) string { return v.Description }).(pulumi.StringOutput) +} + +func (o LookupSecurityGroupResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupSecurityGroupResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the security group. +func (o LookupSecurityGroupResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the security group is associated. +func (o LookupSecurityGroupResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The security group ID. +func (o LookupSecurityGroupResultOutput) SecurityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) string { return v.SecurityGroupId }).(pulumi.StringOutput) +} + +// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. +func (o LookupSecurityGroupResultOutput) Stateful() pulumi.BoolOutput { + return o.ApplyT(func(v LookupSecurityGroupResult) bool { return v.Stateful }).(pulumi.BoolOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSecurityGroupResultOutput{}) +} diff --git a/sdk/go/stackit/getSecurityGroupRule.go b/sdk/go/stackit/getSecurityGroupRule.go new file mode 100644 index 0000000..0e73758 --- /dev/null +++ b/sdk/go/stackit/getSecurityGroupRule.go @@ -0,0 +1,163 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Security group datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSecurityGroupRule(ctx *pulumi.Context, args *LookupSecurityGroupRuleArgs, opts ...pulumi.InvokeOption) (*LookupSecurityGroupRuleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSecurityGroupRuleResult + err := ctx.Invoke("stackit:index/getSecurityGroupRule:getSecurityGroupRule", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSecurityGroupRule. +type LookupSecurityGroupRuleArgs struct { + // STACKIT project ID to which the security group rule is associated. + ProjectId string `pulumi:"projectId"` + // The security group ID. + SecurityGroupId string `pulumi:"securityGroupId"` + // The security group rule ID. + SecurityGroupRuleId string `pulumi:"securityGroupRuleId"` +} + +// A collection of values returned by getSecurityGroupRule. +type LookupSecurityGroupRuleResult struct { + // The description of the security group rule. + Description string `pulumi:"description"` + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction string `pulumi:"direction"` + // The ethertype which the rule should match. + EtherType string `pulumi:"etherType"` + // ICMP Parameters. + IcmpParameters GetSecurityGroupRuleIcmpParameters `pulumi:"icmpParameters"` + Id string `pulumi:"id"` + // The remote IP range which the rule should match. + IpRange string `pulumi:"ipRange"` + // The range of ports. + PortRange GetSecurityGroupRulePortRange `pulumi:"portRange"` + // STACKIT project ID to which the security group rule is associated. + ProjectId string `pulumi:"projectId"` + // The internet protocol which the rule should match. + Protocol GetSecurityGroupRuleProtocol `pulumi:"protocol"` + // The remote security group which the rule should match. + RemoteSecurityGroupId string `pulumi:"remoteSecurityGroupId"` + // The security group ID. + SecurityGroupId string `pulumi:"securityGroupId"` + // The security group rule ID. + SecurityGroupRuleId string `pulumi:"securityGroupRuleId"` +} + +func LookupSecurityGroupRuleOutput(ctx *pulumi.Context, args LookupSecurityGroupRuleOutputArgs, opts ...pulumi.InvokeOption) LookupSecurityGroupRuleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSecurityGroupRuleResultOutput, error) { + args := v.(LookupSecurityGroupRuleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSecurityGroupRule:getSecurityGroupRule", args, LookupSecurityGroupRuleResultOutput{}, options).(LookupSecurityGroupRuleResultOutput), nil + }).(LookupSecurityGroupRuleResultOutput) +} + +// A collection of arguments for invoking getSecurityGroupRule. +type LookupSecurityGroupRuleOutputArgs struct { + // STACKIT project ID to which the security group rule is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The security group ID. + SecurityGroupId pulumi.StringInput `pulumi:"securityGroupId"` + // The security group rule ID. + SecurityGroupRuleId pulumi.StringInput `pulumi:"securityGroupRuleId"` +} + +func (LookupSecurityGroupRuleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecurityGroupRuleArgs)(nil)).Elem() +} + +// A collection of values returned by getSecurityGroupRule. +type LookupSecurityGroupRuleResultOutput struct{ *pulumi.OutputState } + +func (LookupSecurityGroupRuleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSecurityGroupRuleResult)(nil)).Elem() +} + +func (o LookupSecurityGroupRuleResultOutput) ToLookupSecurityGroupRuleResultOutput() LookupSecurityGroupRuleResultOutput { + return o +} + +func (o LookupSecurityGroupRuleResultOutput) ToLookupSecurityGroupRuleResultOutputWithContext(ctx context.Context) LookupSecurityGroupRuleResultOutput { + return o +} + +// The description of the security group rule. +func (o LookupSecurityGroupRuleResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. +func (o LookupSecurityGroupRuleResultOutput) Direction() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.Direction }).(pulumi.StringOutput) +} + +// The ethertype which the rule should match. +func (o LookupSecurityGroupRuleResultOutput) EtherType() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.EtherType }).(pulumi.StringOutput) +} + +// ICMP Parameters. +func (o LookupSecurityGroupRuleResultOutput) IcmpParameters() GetSecurityGroupRuleIcmpParametersOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) GetSecurityGroupRuleIcmpParameters { return v.IcmpParameters }).(GetSecurityGroupRuleIcmpParametersOutput) +} + +func (o LookupSecurityGroupRuleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The remote IP range which the rule should match. +func (o LookupSecurityGroupRuleResultOutput) IpRange() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.IpRange }).(pulumi.StringOutput) +} + +// The range of ports. +func (o LookupSecurityGroupRuleResultOutput) PortRange() GetSecurityGroupRulePortRangeOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) GetSecurityGroupRulePortRange { return v.PortRange }).(GetSecurityGroupRulePortRangeOutput) +} + +// STACKIT project ID to which the security group rule is associated. +func (o LookupSecurityGroupRuleResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The internet protocol which the rule should match. +func (o LookupSecurityGroupRuleResultOutput) Protocol() GetSecurityGroupRuleProtocolOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) GetSecurityGroupRuleProtocol { return v.Protocol }).(GetSecurityGroupRuleProtocolOutput) +} + +// The remote security group which the rule should match. +func (o LookupSecurityGroupRuleResultOutput) RemoteSecurityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.RemoteSecurityGroupId }).(pulumi.StringOutput) +} + +// The security group ID. +func (o LookupSecurityGroupRuleResultOutput) SecurityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.SecurityGroupId }).(pulumi.StringOutput) +} + +// The security group rule ID. +func (o LookupSecurityGroupRuleResultOutput) SecurityGroupRuleId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSecurityGroupRuleResult) string { return v.SecurityGroupRuleId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSecurityGroupRuleResultOutput{}) +} diff --git a/sdk/go/stackit/getServer.go b/sdk/go/stackit/getServer.go new file mode 100644 index 0000000..3648468 --- /dev/null +++ b/sdk/go/stackit/getServer.go @@ -0,0 +1,187 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server datasource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupServer(ctx *pulumi.Context, args *LookupServerArgs, opts ...pulumi.InvokeOption) (*LookupServerResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupServerResult + err := ctx.Invoke("stackit:index/getServer:getServer", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServer. +type LookupServerArgs struct { + // STACKIT project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The server ID. + ServerId string `pulumi:"serverId"` +} + +// A collection of values returned by getServer. +type LookupServerResult struct { + // The affinity group the server is assigned to. + AffinityGroup string `pulumi:"affinityGroup"` + // The availability zone of the server. + AvailabilityZone string `pulumi:"availabilityZone"` + // The boot volume for the server + BootVolume GetServerBootVolume `pulumi:"bootVolume"` + // Date-time when the server was created + CreatedAt string `pulumi:"createdAt"` + Id string `pulumi:"id"` + // The image ID to be used for an ephemeral disk on the server. + ImageId string `pulumi:"imageId"` + // The name of the keypair used during server creation. + KeypairName string `pulumi:"keypairName"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // Date-time when the server was launched + LaunchedAt string `pulumi:"launchedAt"` + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType string `pulumi:"machineType"` + // The name of the server. + Name string `pulumi:"name"` + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces []string `pulumi:"networkInterfaces"` + // STACKIT project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The server ID. + ServerId string `pulumi:"serverId"` + // Date-time when the server was updated + UpdatedAt string `pulumi:"updatedAt"` + // User data that is passed via cloud-init to the server. + UserData string `pulumi:"userData"` +} + +func LookupServerOutput(ctx *pulumi.Context, args LookupServerOutputArgs, opts ...pulumi.InvokeOption) LookupServerResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupServerResultOutput, error) { + args := v.(LookupServerArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServer:getServer", args, LookupServerResultOutput{}, options).(LookupServerResultOutput), nil + }).(LookupServerResultOutput) +} + +// A collection of arguments for invoking getServer. +type LookupServerOutputArgs struct { + // STACKIT project ID to which the server is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The server ID. + ServerId pulumi.StringInput `pulumi:"serverId"` +} + +func (LookupServerOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerArgs)(nil)).Elem() +} + +// A collection of values returned by getServer. +type LookupServerResultOutput struct{ *pulumi.OutputState } + +func (LookupServerResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerResult)(nil)).Elem() +} + +func (o LookupServerResultOutput) ToLookupServerResultOutput() LookupServerResultOutput { + return o +} + +func (o LookupServerResultOutput) ToLookupServerResultOutputWithContext(ctx context.Context) LookupServerResultOutput { + return o +} + +// The affinity group the server is assigned to. +func (o LookupServerResultOutput) AffinityGroup() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.AffinityGroup }).(pulumi.StringOutput) +} + +// The availability zone of the server. +func (o LookupServerResultOutput) AvailabilityZone() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.AvailabilityZone }).(pulumi.StringOutput) +} + +// The boot volume for the server +func (o LookupServerResultOutput) BootVolume() GetServerBootVolumeOutput { + return o.ApplyT(func(v LookupServerResult) GetServerBootVolume { return v.BootVolume }).(GetServerBootVolumeOutput) +} + +// Date-time when the server was created +func (o LookupServerResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +func (o LookupServerResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The image ID to be used for an ephemeral disk on the server. +func (o LookupServerResultOutput) ImageId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.ImageId }).(pulumi.StringOutput) +} + +// The name of the keypair used during server creation. +func (o LookupServerResultOutput) KeypairName() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.KeypairName }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupServerResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupServerResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// Date-time when the server was launched +func (o LookupServerResultOutput) LaunchedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.LaunchedAt }).(pulumi.StringOutput) +} + +// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) +func (o LookupServerResultOutput) MachineType() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.MachineType }).(pulumi.StringOutput) +} + +// The name of the server. +func (o LookupServerResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. +func (o LookupServerResultOutput) NetworkInterfaces() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupServerResult) []string { return v.NetworkInterfaces }).(pulumi.StringArrayOutput) +} + +// STACKIT project ID to which the server is associated. +func (o LookupServerResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID. +func (o LookupServerResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +// Date-time when the server was updated +func (o LookupServerResultOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// User data that is passed via cloud-init to the server. +func (o LookupServerResultOutput) UserData() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerResult) string { return v.UserData }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupServerResultOutput{}) +} diff --git a/sdk/go/stackit/getServerBackupSchedule.go b/sdk/go/stackit/getServerBackupSchedule.go new file mode 100644 index 0000000..bb3e922 --- /dev/null +++ b/sdk/go/stackit/getServerBackupSchedule.go @@ -0,0 +1,150 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func LookupServerBackupSchedule(ctx *pulumi.Context, args *LookupServerBackupScheduleArgs, opts ...pulumi.InvokeOption) (*LookupServerBackupScheduleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupServerBackupScheduleResult + err := ctx.Invoke("stackit:index/getServerBackupSchedule:getServerBackupSchedule", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServerBackupSchedule. +type LookupServerBackupScheduleArgs struct { + // Backup schedule ID. + BackupScheduleId int `pulumi:"backupScheduleId"` + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID for the backup schedule. + ServerId string `pulumi:"serverId"` +} + +// A collection of values returned by getServerBackupSchedule. +type LookupServerBackupScheduleResult struct { + // Backup schedule details for the backups. + BackupProperties GetServerBackupScheduleBackupProperties `pulumi:"backupProperties"` + // Backup schedule ID. + BackupScheduleId int `pulumi:"backupScheduleId"` + // Is the backup schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + Id string `pulumi:"id"` + // The schedule name. + Name string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` + // Server ID for the backup schedule. + ServerId string `pulumi:"serverId"` +} + +func LookupServerBackupScheduleOutput(ctx *pulumi.Context, args LookupServerBackupScheduleOutputArgs, opts ...pulumi.InvokeOption) LookupServerBackupScheduleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupServerBackupScheduleResultOutput, error) { + args := v.(LookupServerBackupScheduleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServerBackupSchedule:getServerBackupSchedule", args, LookupServerBackupScheduleResultOutput{}, options).(LookupServerBackupScheduleResultOutput), nil + }).(LookupServerBackupScheduleResultOutput) +} + +// A collection of arguments for invoking getServerBackupSchedule. +type LookupServerBackupScheduleOutputArgs struct { + // Backup schedule ID. + BackupScheduleId pulumi.IntInput `pulumi:"backupScheduleId"` + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // Server ID for the backup schedule. + ServerId pulumi.StringInput `pulumi:"serverId"` +} + +func (LookupServerBackupScheduleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerBackupScheduleArgs)(nil)).Elem() +} + +// A collection of values returned by getServerBackupSchedule. +type LookupServerBackupScheduleResultOutput struct{ *pulumi.OutputState } + +func (LookupServerBackupScheduleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerBackupScheduleResult)(nil)).Elem() +} + +func (o LookupServerBackupScheduleResultOutput) ToLookupServerBackupScheduleResultOutput() LookupServerBackupScheduleResultOutput { + return o +} + +func (o LookupServerBackupScheduleResultOutput) ToLookupServerBackupScheduleResultOutputWithContext(ctx context.Context) LookupServerBackupScheduleResultOutput { + return o +} + +// Backup schedule details for the backups. +func (o LookupServerBackupScheduleResultOutput) BackupProperties() GetServerBackupScheduleBackupPropertiesOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) GetServerBackupScheduleBackupProperties { + return v.BackupProperties + }).(GetServerBackupScheduleBackupPropertiesOutput) +} + +// Backup schedule ID. +func (o LookupServerBackupScheduleResultOutput) BackupScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) int { return v.BackupScheduleId }).(pulumi.IntOutput) +} + +// Is the backup schedule enabled or disabled. +func (o LookupServerBackupScheduleResultOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +func (o LookupServerBackupScheduleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The schedule name. +func (o LookupServerBackupScheduleResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the server is associated. +func (o LookupServerBackupScheduleResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupServerBackupScheduleResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Backup schedule described in `rrule` (recurrence rule) format. +func (o LookupServerBackupScheduleResultOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) string { return v.Rrule }).(pulumi.StringOutput) +} + +// Server ID for the backup schedule. +func (o LookupServerBackupScheduleResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerBackupScheduleResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupServerBackupScheduleResultOutput{}) +} diff --git a/sdk/go/stackit/getServerBackupSchedules.go b/sdk/go/stackit/getServerBackupSchedules.go new file mode 100644 index 0000000..13021f3 --- /dev/null +++ b/sdk/go/stackit/getServerBackupSchedules.go @@ -0,0 +1,114 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func GetServerBackupSchedules(ctx *pulumi.Context, args *GetServerBackupSchedulesArgs, opts ...pulumi.InvokeOption) (*GetServerBackupSchedulesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetServerBackupSchedulesResult + err := ctx.Invoke("stackit:index/getServerBackupSchedules:getServerBackupSchedules", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServerBackupSchedules. +type GetServerBackupSchedulesArgs struct { + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID (UUID) to which the backup schedule is associated. + ServerId string `pulumi:"serverId"` +} + +// A collection of values returned by getServerBackupSchedules. +type GetServerBackupSchedulesResult struct { + Id string `pulumi:"id"` + Items []GetServerBackupSchedulesItem `pulumi:"items"` + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID (UUID) to which the backup schedule is associated. + ServerId string `pulumi:"serverId"` +} + +func GetServerBackupSchedulesOutput(ctx *pulumi.Context, args GetServerBackupSchedulesOutputArgs, opts ...pulumi.InvokeOption) GetServerBackupSchedulesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetServerBackupSchedulesResultOutput, error) { + args := v.(GetServerBackupSchedulesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServerBackupSchedules:getServerBackupSchedules", args, GetServerBackupSchedulesResultOutput{}, options).(GetServerBackupSchedulesResultOutput), nil + }).(GetServerBackupSchedulesResultOutput) +} + +// A collection of arguments for invoking getServerBackupSchedules. +type GetServerBackupSchedulesOutputArgs struct { + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // Server ID (UUID) to which the backup schedule is associated. + ServerId pulumi.StringInput `pulumi:"serverId"` +} + +func (GetServerBackupSchedulesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesArgs)(nil)).Elem() +} + +// A collection of values returned by getServerBackupSchedules. +type GetServerBackupSchedulesResultOutput struct{ *pulumi.OutputState } + +func (GetServerBackupSchedulesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesResult)(nil)).Elem() +} + +func (o GetServerBackupSchedulesResultOutput) ToGetServerBackupSchedulesResultOutput() GetServerBackupSchedulesResultOutput { + return o +} + +func (o GetServerBackupSchedulesResultOutput) ToGetServerBackupSchedulesResultOutputWithContext(ctx context.Context) GetServerBackupSchedulesResultOutput { + return o +} + +func (o GetServerBackupSchedulesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetServerBackupSchedulesResultOutput) Items() GetServerBackupSchedulesItemArrayOutput { + return o.ApplyT(func(v GetServerBackupSchedulesResult) []GetServerBackupSchedulesItem { return v.Items }).(GetServerBackupSchedulesItemArrayOutput) +} + +// STACKIT Project ID (UUID) to which the server is associated. +func (o GetServerBackupSchedulesResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o GetServerBackupSchedulesResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetServerBackupSchedulesResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Server ID (UUID) to which the backup schedule is associated. +func (o GetServerBackupSchedulesResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetServerBackupSchedulesResultOutput{}) +} diff --git a/sdk/go/stackit/getServerUpdateSchedule.go b/sdk/go/stackit/getServerUpdateSchedule.go new file mode 100644 index 0000000..247789e --- /dev/null +++ b/sdk/go/stackit/getServerUpdateSchedule.go @@ -0,0 +1,148 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server update schedule datasource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func LookupServerUpdateSchedule(ctx *pulumi.Context, args *LookupServerUpdateScheduleArgs, opts ...pulumi.InvokeOption) (*LookupServerUpdateScheduleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupServerUpdateScheduleResult + err := ctx.Invoke("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServerUpdateSchedule. +type LookupServerUpdateScheduleArgs struct { + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID for the update schedule. + ServerId string `pulumi:"serverId"` + // Update schedule ID. + UpdateScheduleId int `pulumi:"updateScheduleId"` +} + +// A collection of values returned by getServerUpdateSchedule. +type LookupServerUpdateScheduleResult struct { + // Is the update schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + Id string `pulumi:"id"` + // Maintenance window [1..24]. + MaintenanceWindow int `pulumi:"maintenanceWindow"` + // The schedule name. + Name string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` + // Server ID for the update schedule. + ServerId string `pulumi:"serverId"` + // Update schedule ID. + UpdateScheduleId int `pulumi:"updateScheduleId"` +} + +func LookupServerUpdateScheduleOutput(ctx *pulumi.Context, args LookupServerUpdateScheduleOutputArgs, opts ...pulumi.InvokeOption) LookupServerUpdateScheduleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupServerUpdateScheduleResultOutput, error) { + args := v.(LookupServerUpdateScheduleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", args, LookupServerUpdateScheduleResultOutput{}, options).(LookupServerUpdateScheduleResultOutput), nil + }).(LookupServerUpdateScheduleResultOutput) +} + +// A collection of arguments for invoking getServerUpdateSchedule. +type LookupServerUpdateScheduleOutputArgs struct { + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // Server ID for the update schedule. + ServerId pulumi.StringInput `pulumi:"serverId"` + // Update schedule ID. + UpdateScheduleId pulumi.IntInput `pulumi:"updateScheduleId"` +} + +func (LookupServerUpdateScheduleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerUpdateScheduleArgs)(nil)).Elem() +} + +// A collection of values returned by getServerUpdateSchedule. +type LookupServerUpdateScheduleResultOutput struct{ *pulumi.OutputState } + +func (LookupServerUpdateScheduleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServerUpdateScheduleResult)(nil)).Elem() +} + +func (o LookupServerUpdateScheduleResultOutput) ToLookupServerUpdateScheduleResultOutput() LookupServerUpdateScheduleResultOutput { + return o +} + +func (o LookupServerUpdateScheduleResultOutput) ToLookupServerUpdateScheduleResultOutputWithContext(ctx context.Context) LookupServerUpdateScheduleResultOutput { + return o +} + +// Is the update schedule enabled or disabled. +func (o LookupServerUpdateScheduleResultOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +func (o LookupServerUpdateScheduleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Maintenance window [1..24]. +func (o LookupServerUpdateScheduleResultOutput) MaintenanceWindow() pulumi.IntOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) int { return v.MaintenanceWindow }).(pulumi.IntOutput) +} + +// The schedule name. +func (o LookupServerUpdateScheduleResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the server is associated. +func (o LookupServerUpdateScheduleResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupServerUpdateScheduleResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Update schedule described in `rrule` (recurrence rule) format. +func (o LookupServerUpdateScheduleResultOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) string { return v.Rrule }).(pulumi.StringOutput) +} + +// Server ID for the update schedule. +func (o LookupServerUpdateScheduleResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +// Update schedule ID. +func (o LookupServerUpdateScheduleResultOutput) UpdateScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v LookupServerUpdateScheduleResult) int { return v.UpdateScheduleId }).(pulumi.IntOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupServerUpdateScheduleResultOutput{}) +} diff --git a/sdk/go/stackit/getServerUpdateSchedules.go b/sdk/go/stackit/getServerUpdateSchedules.go new file mode 100644 index 0000000..37e0ef1 --- /dev/null +++ b/sdk/go/stackit/getServerUpdateSchedules.go @@ -0,0 +1,114 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server update schedules datasource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +func GetServerUpdateSchedules(ctx *pulumi.Context, args *GetServerUpdateSchedulesArgs, opts ...pulumi.InvokeOption) (*GetServerUpdateSchedulesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetServerUpdateSchedulesResult + err := ctx.Invoke("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServerUpdateSchedules. +type GetServerUpdateSchedulesArgs struct { + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID (UUID) to which the update schedule is associated. + ServerId string `pulumi:"serverId"` +} + +// A collection of values returned by getServerUpdateSchedules. +type GetServerUpdateSchedulesResult struct { + Id string `pulumi:"id"` + Items []GetServerUpdateSchedulesItem `pulumi:"items"` + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Server ID (UUID) to which the update schedule is associated. + ServerId string `pulumi:"serverId"` +} + +func GetServerUpdateSchedulesOutput(ctx *pulumi.Context, args GetServerUpdateSchedulesOutputArgs, opts ...pulumi.InvokeOption) GetServerUpdateSchedulesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetServerUpdateSchedulesResultOutput, error) { + args := v.(GetServerUpdateSchedulesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", args, GetServerUpdateSchedulesResultOutput{}, options).(GetServerUpdateSchedulesResultOutput), nil + }).(GetServerUpdateSchedulesResultOutput) +} + +// A collection of arguments for invoking getServerUpdateSchedules. +type GetServerUpdateSchedulesOutputArgs struct { + // STACKIT Project ID (UUID) to which the server is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // Server ID (UUID) to which the update schedule is associated. + ServerId pulumi.StringInput `pulumi:"serverId"` +} + +func (GetServerUpdateSchedulesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerUpdateSchedulesArgs)(nil)).Elem() +} + +// A collection of values returned by getServerUpdateSchedules. +type GetServerUpdateSchedulesResultOutput struct{ *pulumi.OutputState } + +func (GetServerUpdateSchedulesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerUpdateSchedulesResult)(nil)).Elem() +} + +func (o GetServerUpdateSchedulesResultOutput) ToGetServerUpdateSchedulesResultOutput() GetServerUpdateSchedulesResultOutput { + return o +} + +func (o GetServerUpdateSchedulesResultOutput) ToGetServerUpdateSchedulesResultOutputWithContext(ctx context.Context) GetServerUpdateSchedulesResultOutput { + return o +} + +func (o GetServerUpdateSchedulesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetServerUpdateSchedulesResultOutput) Items() GetServerUpdateSchedulesItemArrayOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesResult) []GetServerUpdateSchedulesItem { return v.Items }).(GetServerUpdateSchedulesItemArrayOutput) +} + +// STACKIT Project ID (UUID) to which the server is associated. +func (o GetServerUpdateSchedulesResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o GetServerUpdateSchedulesResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Server ID (UUID) to which the update schedule is associated. +func (o GetServerUpdateSchedulesResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetServerUpdateSchedulesResultOutput{}) +} diff --git a/sdk/go/stackit/getServiceAccount.go b/sdk/go/stackit/getServiceAccount.go new file mode 100644 index 0000000..8d50592 --- /dev/null +++ b/sdk/go/stackit/getServiceAccount.go @@ -0,0 +1,103 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Service account data source schema. +// +// ## Example Usage +func LookupServiceAccount(ctx *pulumi.Context, args *LookupServiceAccountArgs, opts ...pulumi.InvokeOption) (*LookupServiceAccountResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupServiceAccountResult + err := ctx.Invoke("stackit:index/getServiceAccount:getServiceAccount", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getServiceAccount. +type LookupServiceAccountArgs struct { + // Email of the service account. + Email string `pulumi:"email"` + // STACKIT project ID to which the service account is associated. + ProjectId string `pulumi:"projectId"` +} + +// A collection of values returned by getServiceAccount. +type LookupServiceAccountResult struct { + // Email of the service account. + Email string `pulumi:"email"` + Id string `pulumi:"id"` + // Name of the service account. + Name string `pulumi:"name"` + // STACKIT project ID to which the service account is associated. + ProjectId string `pulumi:"projectId"` +} + +func LookupServiceAccountOutput(ctx *pulumi.Context, args LookupServiceAccountOutputArgs, opts ...pulumi.InvokeOption) LookupServiceAccountResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupServiceAccountResultOutput, error) { + args := v.(LookupServiceAccountArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getServiceAccount:getServiceAccount", args, LookupServiceAccountResultOutput{}, options).(LookupServiceAccountResultOutput), nil + }).(LookupServiceAccountResultOutput) +} + +// A collection of arguments for invoking getServiceAccount. +type LookupServiceAccountOutputArgs struct { + // Email of the service account. + Email pulumi.StringInput `pulumi:"email"` + // STACKIT project ID to which the service account is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` +} + +func (LookupServiceAccountOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServiceAccountArgs)(nil)).Elem() +} + +// A collection of values returned by getServiceAccount. +type LookupServiceAccountResultOutput struct{ *pulumi.OutputState } + +func (LookupServiceAccountResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupServiceAccountResult)(nil)).Elem() +} + +func (o LookupServiceAccountResultOutput) ToLookupServiceAccountResultOutput() LookupServiceAccountResultOutput { + return o +} + +func (o LookupServiceAccountResultOutput) ToLookupServiceAccountResultOutputWithContext(ctx context.Context) LookupServiceAccountResultOutput { + return o +} + +// Email of the service account. +func (o LookupServiceAccountResultOutput) Email() pulumi.StringOutput { + return o.ApplyT(func(v LookupServiceAccountResult) string { return v.Email }).(pulumi.StringOutput) +} + +func (o LookupServiceAccountResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupServiceAccountResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Name of the service account. +func (o LookupServiceAccountResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupServiceAccountResult) string { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the service account is associated. +func (o LookupServiceAccountResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupServiceAccountResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupServiceAccountResultOutput{}) +} diff --git a/sdk/go/stackit/getSkeCluster.go b/sdk/go/stackit/getSkeCluster.go new file mode 100644 index 0000000..7cf003c --- /dev/null +++ b/sdk/go/stackit/getSkeCluster.go @@ -0,0 +1,189 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SKE Cluster data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSkeCluster(ctx *pulumi.Context, args *LookupSkeClusterArgs, opts ...pulumi.InvokeOption) (*LookupSkeClusterResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSkeClusterResult + err := ctx.Invoke("stackit:index/getSkeCluster:getSkeCluster", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSkeCluster. +type LookupSkeClusterArgs struct { + // The cluster name. + Name string `pulumi:"name"` + // STACKIT project ID to which the cluster is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getSkeCluster. +type LookupSkeClusterResult struct { + // DEPRECATED as of Kubernetes 1.25+ + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // + // Deprecated: Please remove this flag from your configuration when using Kubernetes version 1.25+. + AllowPrivilegedContainers bool `pulumi:"allowPrivilegedContainers"` + // The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + EgressAddressRanges []string `pulumi:"egressAddressRanges"` + // A single extensions block as defined below + Extensions GetSkeClusterExtensions `pulumi:"extensions"` + // One or more hibernation block as defined below. + Hibernations []GetSkeClusterHibernation `pulumi:"hibernations"` + Id string `pulumi:"id"` + // Kubernetes version. This field is deprecated, use `kubernetesVersionUsed` instead + // + // Deprecated: This field is always nil, use `kubernetesVersionUsed` to get the cluster kubernetes version. This field would cause errors when the cluster got a kubernetes version minor upgrade, either triggered by automatic or forceful updates. + KubernetesVersion string `pulumi:"kubernetesVersion"` + // The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetesVersionUsed` field. + KubernetesVersionMin string `pulumi:"kubernetesVersionMin"` + // Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15` + KubernetesVersionUsed string `pulumi:"kubernetesVersionUsed"` + // A single maintenance block as defined below + Maintenance GetSkeClusterMaintenance `pulumi:"maintenance"` + // The cluster name. + Name string `pulumi:"name"` + // Network block as defined below. + Network GetSkeClusterNetwork `pulumi:"network"` + // One or more `nodePool` block as defined below. + NodePools []GetSkeClusterNodePool `pulumi:"nodePools"` + // STACKIT project ID to which the cluster is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +func LookupSkeClusterOutput(ctx *pulumi.Context, args LookupSkeClusterOutputArgs, opts ...pulumi.InvokeOption) LookupSkeClusterResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSkeClusterResultOutput, error) { + args := v.(LookupSkeClusterArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSkeCluster:getSkeCluster", args, LookupSkeClusterResultOutput{}, options).(LookupSkeClusterResultOutput), nil + }).(LookupSkeClusterResultOutput) +} + +// A collection of arguments for invoking getSkeCluster. +type LookupSkeClusterOutputArgs struct { + // The cluster name. + Name pulumi.StringInput `pulumi:"name"` + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupSkeClusterOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSkeClusterArgs)(nil)).Elem() +} + +// A collection of values returned by getSkeCluster. +type LookupSkeClusterResultOutput struct{ *pulumi.OutputState } + +func (LookupSkeClusterResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSkeClusterResult)(nil)).Elem() +} + +func (o LookupSkeClusterResultOutput) ToLookupSkeClusterResultOutput() LookupSkeClusterResultOutput { + return o +} + +func (o LookupSkeClusterResultOutput) ToLookupSkeClusterResultOutputWithContext(ctx context.Context) LookupSkeClusterResultOutput { + return o +} + +// DEPRECATED as of Kubernetes 1.25+ +// Flag to specify if privileged mode for containers is enabled or not. +// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). +// +// Deprecated: Please remove this flag from your configuration when using Kubernetes version 1.25+. +func (o LookupSkeClusterResultOutput) AllowPrivilegedContainers() pulumi.BoolOutput { + return o.ApplyT(func(v LookupSkeClusterResult) bool { return v.AllowPrivilegedContainers }).(pulumi.BoolOutput) +} + +// The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. +func (o LookupSkeClusterResultOutput) EgressAddressRanges() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupSkeClusterResult) []string { return v.EgressAddressRanges }).(pulumi.StringArrayOutput) +} + +// A single extensions block as defined below +func (o LookupSkeClusterResultOutput) Extensions() GetSkeClusterExtensionsOutput { + return o.ApplyT(func(v LookupSkeClusterResult) GetSkeClusterExtensions { return v.Extensions }).(GetSkeClusterExtensionsOutput) +} + +// One or more hibernation block as defined below. +func (o LookupSkeClusterResultOutput) Hibernations() GetSkeClusterHibernationArrayOutput { + return o.ApplyT(func(v LookupSkeClusterResult) []GetSkeClusterHibernation { return v.Hibernations }).(GetSkeClusterHibernationArrayOutput) +} + +func (o LookupSkeClusterResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Kubernetes version. This field is deprecated, use `kubernetesVersionUsed` instead +// +// Deprecated: This field is always nil, use `kubernetesVersionUsed` to get the cluster kubernetes version. This field would cause errors when the cluster got a kubernetes version minor upgrade, either triggered by automatic or forceful updates. +func (o LookupSkeClusterResultOutput) KubernetesVersion() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.KubernetesVersion }).(pulumi.StringOutput) +} + +// The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetesVersionUsed` field. +func (o LookupSkeClusterResultOutput) KubernetesVersionMin() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.KubernetesVersionMin }).(pulumi.StringOutput) +} + +// Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15` +func (o LookupSkeClusterResultOutput) KubernetesVersionUsed() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.KubernetesVersionUsed }).(pulumi.StringOutput) +} + +// A single maintenance block as defined below +func (o LookupSkeClusterResultOutput) Maintenance() GetSkeClusterMaintenanceOutput { + return o.ApplyT(func(v LookupSkeClusterResult) GetSkeClusterMaintenance { return v.Maintenance }).(GetSkeClusterMaintenanceOutput) +} + +// The cluster name. +func (o LookupSkeClusterResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Network block as defined below. +func (o LookupSkeClusterResultOutput) Network() GetSkeClusterNetworkOutput { + return o.ApplyT(func(v LookupSkeClusterResult) GetSkeClusterNetwork { return v.Network }).(GetSkeClusterNetworkOutput) +} + +// One or more `nodePool` block as defined below. +func (o LookupSkeClusterResultOutput) NodePools() GetSkeClusterNodePoolArrayOutput { + return o.ApplyT(func(v LookupSkeClusterResult) []GetSkeClusterNodePool { return v.NodePools }).(GetSkeClusterNodePoolArrayOutput) +} + +// STACKIT project ID to which the cluster is associated. +func (o LookupSkeClusterResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSkeClusterResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupSkeClusterResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupSkeClusterResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSkeClusterResultOutput{}) +} diff --git a/sdk/go/stackit/getSqlserverflexInstance.go b/sdk/go/stackit/getSqlserverflexInstance.go new file mode 100644 index 0000000..2f5fef8 --- /dev/null +++ b/sdk/go/stackit/getSqlserverflexInstance.go @@ -0,0 +1,155 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSqlserverflexInstance(ctx *pulumi.Context, args *LookupSqlserverflexInstanceArgs, opts ...pulumi.InvokeOption) (*LookupSqlserverflexInstanceResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSqlserverflexInstanceResult + err := ctx.Invoke("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSqlserverflexInstance. +type LookupSqlserverflexInstanceArgs struct { + // ID of the SQLServer Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// A collection of values returned by getSqlserverflexInstance. +type LookupSqlserverflexInstanceResult struct { + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule string `pulumi:"backupSchedule"` + Flavor GetSqlserverflexInstanceFlavor `pulumi:"flavor"` + Id string `pulumi:"id"` + // ID of the SQLServer Flex instance. + InstanceId string `pulumi:"instanceId"` + // Instance name. + Name string `pulumi:"name"` + // Custom parameters for the SQLServer Flex instance. + Options GetSqlserverflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Replicas int `pulumi:"replicas"` + Storage GetSqlserverflexInstanceStorage `pulumi:"storage"` + Version string `pulumi:"version"` +} + +func LookupSqlserverflexInstanceOutput(ctx *pulumi.Context, args LookupSqlserverflexInstanceOutputArgs, opts ...pulumi.InvokeOption) LookupSqlserverflexInstanceResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSqlserverflexInstanceResultOutput, error) { + args := v.(LookupSqlserverflexInstanceArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", args, LookupSqlserverflexInstanceResultOutput{}, options).(LookupSqlserverflexInstanceResultOutput), nil + }).(LookupSqlserverflexInstanceResultOutput) +} + +// A collection of arguments for invoking getSqlserverflexInstance. +type LookupSqlserverflexInstanceOutputArgs struct { + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` +} + +func (LookupSqlserverflexInstanceOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSqlserverflexInstanceArgs)(nil)).Elem() +} + +// A collection of values returned by getSqlserverflexInstance. +type LookupSqlserverflexInstanceResultOutput struct{ *pulumi.OutputState } + +func (LookupSqlserverflexInstanceResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSqlserverflexInstanceResult)(nil)).Elem() +} + +func (o LookupSqlserverflexInstanceResultOutput) ToLookupSqlserverflexInstanceResultOutput() LookupSqlserverflexInstanceResultOutput { + return o +} + +func (o LookupSqlserverflexInstanceResultOutput) ToLookupSqlserverflexInstanceResultOutputWithContext(ctx context.Context) LookupSqlserverflexInstanceResultOutput { + return o +} + +// The Access Control List (ACL) for the SQLServer Flex instance. +func (o LookupSqlserverflexInstanceResultOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). +func (o LookupSqlserverflexInstanceResultOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o LookupSqlserverflexInstanceResultOutput) Flavor() GetSqlserverflexInstanceFlavorOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) GetSqlserverflexInstanceFlavor { return v.Flavor }).(GetSqlserverflexInstanceFlavorOutput) +} + +func (o LookupSqlserverflexInstanceResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the SQLServer Flex instance. +func (o LookupSqlserverflexInstanceResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LookupSqlserverflexInstanceResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Custom parameters for the SQLServer Flex instance. +func (o LookupSqlserverflexInstanceResultOutput) Options() GetSqlserverflexInstanceOptionsOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) GetSqlserverflexInstanceOptions { return v.Options }).(GetSqlserverflexInstanceOptionsOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupSqlserverflexInstanceResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupSqlserverflexInstanceResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +func (o LookupSqlserverflexInstanceResultOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) int { return v.Replicas }).(pulumi.IntOutput) +} + +func (o LookupSqlserverflexInstanceResultOutput) Storage() GetSqlserverflexInstanceStorageOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) GetSqlserverflexInstanceStorage { return v.Storage }).(GetSqlserverflexInstanceStorageOutput) +} + +func (o LookupSqlserverflexInstanceResultOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexInstanceResult) string { return v.Version }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSqlserverflexInstanceResultOutput{}) +} diff --git a/sdk/go/stackit/getSqlserverflexUser.go b/sdk/go/stackit/getSqlserverflexUser.go new file mode 100644 index 0000000..6da6864 --- /dev/null +++ b/sdk/go/stackit/getSqlserverflexUser.go @@ -0,0 +1,142 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupSqlserverflexUser(ctx *pulumi.Context, args *LookupSqlserverflexUserArgs, opts ...pulumi.InvokeOption) (*LookupSqlserverflexUserResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupSqlserverflexUserResult + err := ctx.Invoke("stackit:index/getSqlserverflexUser:getSqlserverflexUser", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getSqlserverflexUser. +type LookupSqlserverflexUserArgs struct { + // ID of the SQLServer Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // User ID. + UserId string `pulumi:"userId"` +} + +// A collection of values returned by getSqlserverflexUser. +type LookupSqlserverflexUserResult struct { + Host string `pulumi:"host"` + Id string `pulumi:"id"` + // ID of the SQLServer Flex instance. + InstanceId string `pulumi:"instanceId"` + Port int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Database access levels for the user. + Roles []string `pulumi:"roles"` + // User ID. + UserId string `pulumi:"userId"` + // Username of the SQLServer Flex instance. + Username string `pulumi:"username"` +} + +func LookupSqlserverflexUserOutput(ctx *pulumi.Context, args LookupSqlserverflexUserOutputArgs, opts ...pulumi.InvokeOption) LookupSqlserverflexUserResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupSqlserverflexUserResultOutput, error) { + args := v.(LookupSqlserverflexUserArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getSqlserverflexUser:getSqlserverflexUser", args, LookupSqlserverflexUserResultOutput{}, options).(LookupSqlserverflexUserResultOutput), nil + }).(LookupSqlserverflexUserResultOutput) +} + +// A collection of arguments for invoking getSqlserverflexUser. +type LookupSqlserverflexUserOutputArgs struct { + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringInput `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput `pulumi:"region"` + // User ID. + UserId pulumi.StringInput `pulumi:"userId"` +} + +func (LookupSqlserverflexUserOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSqlserverflexUserArgs)(nil)).Elem() +} + +// A collection of values returned by getSqlserverflexUser. +type LookupSqlserverflexUserResultOutput struct{ *pulumi.OutputState } + +func (LookupSqlserverflexUserResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupSqlserverflexUserResult)(nil)).Elem() +} + +func (o LookupSqlserverflexUserResultOutput) ToLookupSqlserverflexUserResultOutput() LookupSqlserverflexUserResultOutput { + return o +} + +func (o LookupSqlserverflexUserResultOutput) ToLookupSqlserverflexUserResultOutputWithContext(ctx context.Context) LookupSqlserverflexUserResultOutput { + return o +} + +func (o LookupSqlserverflexUserResultOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.Host }).(pulumi.StringOutput) +} + +func (o LookupSqlserverflexUserResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.Id }).(pulumi.StringOutput) +} + +// ID of the SQLServer Flex instance. +func (o LookupSqlserverflexUserResultOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LookupSqlserverflexUserResultOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) int { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LookupSqlserverflexUserResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LookupSqlserverflexUserResultOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Database access levels for the user. +func (o LookupSqlserverflexUserResultOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) []string { return v.Roles }).(pulumi.StringArrayOutput) +} + +// User ID. +func (o LookupSqlserverflexUserResultOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.UserId }).(pulumi.StringOutput) +} + +// Username of the SQLServer Flex instance. +func (o LookupSqlserverflexUserResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupSqlserverflexUserResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupSqlserverflexUserResultOutput{}) +} diff --git a/sdk/go/stackit/getVolume.go b/sdk/go/stackit/getVolume.go new file mode 100644 index 0000000..2d2a95d --- /dev/null +++ b/sdk/go/stackit/getVolume.go @@ -0,0 +1,152 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Volume resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +func LookupVolume(ctx *pulumi.Context, args *LookupVolumeArgs, opts ...pulumi.InvokeOption) (*LookupVolumeResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupVolumeResult + err := ctx.Invoke("stackit:index/getVolume:getVolume", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getVolume. +type LookupVolumeArgs struct { + // STACKIT project ID to which the volume is associated. + ProjectId string `pulumi:"projectId"` + // The volume ID. + VolumeId string `pulumi:"volumeId"` +} + +// A collection of values returned by getVolume. +type LookupVolumeResult struct { + // The availability zone of the volume. + AvailabilityZone string `pulumi:"availabilityZone"` + // The description of the volume. + Description string `pulumi:"description"` + Id string `pulumi:"id"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the volume. + Name string `pulumi:"name"` + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass string `pulumi:"performanceClass"` + // STACKIT project ID to which the volume is associated. + ProjectId string `pulumi:"projectId"` + // The server ID of the server to which the volume is attached to. + ServerId string `pulumi:"serverId"` + // The size of the volume in GB. It can only be updated to a larger value than the current size + Size int `pulumi:"size"` + // The source of the volume. It can be either a volume, an image, a snapshot or a backup + Source GetVolumeSource `pulumi:"source"` + // The volume ID. + VolumeId string `pulumi:"volumeId"` +} + +func LookupVolumeOutput(ctx *pulumi.Context, args LookupVolumeOutputArgs, opts ...pulumi.InvokeOption) LookupVolumeResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupVolumeResultOutput, error) { + args := v.(LookupVolumeArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("stackit:index/getVolume:getVolume", args, LookupVolumeResultOutput{}, options).(LookupVolumeResultOutput), nil + }).(LookupVolumeResultOutput) +} + +// A collection of arguments for invoking getVolume. +type LookupVolumeOutputArgs struct { + // STACKIT project ID to which the volume is associated. + ProjectId pulumi.StringInput `pulumi:"projectId"` + // The volume ID. + VolumeId pulumi.StringInput `pulumi:"volumeId"` +} + +func (LookupVolumeOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupVolumeArgs)(nil)).Elem() +} + +// A collection of values returned by getVolume. +type LookupVolumeResultOutput struct{ *pulumi.OutputState } + +func (LookupVolumeResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupVolumeResult)(nil)).Elem() +} + +func (o LookupVolumeResultOutput) ToLookupVolumeResultOutput() LookupVolumeResultOutput { + return o +} + +func (o LookupVolumeResultOutput) ToLookupVolumeResultOutputWithContext(ctx context.Context) LookupVolumeResultOutput { + return o +} + +// The availability zone of the volume. +func (o LookupVolumeResultOutput) AvailabilityZone() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.AvailabilityZone }).(pulumi.StringOutput) +} + +// The description of the volume. +func (o LookupVolumeResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.Description }).(pulumi.StringOutput) +} + +func (o LookupVolumeResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o LookupVolumeResultOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v LookupVolumeResult) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the volume. +func (o LookupVolumeResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) +func (o LookupVolumeResultOutput) PerformanceClass() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.PerformanceClass }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the volume is associated. +func (o LookupVolumeResultOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID of the server to which the volume is attached to. +func (o LookupVolumeResultOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.ServerId }).(pulumi.StringOutput) +} + +// The size of the volume in GB. It can only be updated to a larger value than the current size +func (o LookupVolumeResultOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v LookupVolumeResult) int { return v.Size }).(pulumi.IntOutput) +} + +// The source of the volume. It can be either a volume, an image, a snapshot or a backup +func (o LookupVolumeResultOutput) Source() GetVolumeSourceOutput { + return o.ApplyT(func(v LookupVolumeResult) GetVolumeSource { return v.Source }).(GetVolumeSourceOutput) +} + +// The volume ID. +func (o LookupVolumeResultOutput) VolumeId() pulumi.StringOutput { + return o.ApplyT(func(v LookupVolumeResult) string { return v.VolumeId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupVolumeResultOutput{}) +} diff --git a/sdk/go/stackit/git.go b/sdk/go/stackit/git.go new file mode 100644 index 0000000..9d2d67d --- /dev/null +++ b/sdk/go/stackit/git.go @@ -0,0 +1,271 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Git Instance resource schema. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +type Git struct { + pulumi.CustomResourceState + + // ID linked to the git instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Unique name linked to the git instance. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the git instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Url linked to the git instance. + Url pulumi.StringOutput `pulumi:"url"` + // Version linked to the git instance. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewGit registers a new resource with the given unique name, arguments, and options. +func NewGit(ctx *pulumi.Context, + name string, args *GitArgs, opts ...pulumi.ResourceOption) (*Git, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Git + err := ctx.RegisterResource("stackit:index/git:Git", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetGit gets an existing Git 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 GetGit(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *GitState, opts ...pulumi.ResourceOption) (*Git, error) { + var resource Git + err := ctx.ReadResource("stackit:index/git:Git", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Git resources. +type gitState struct { + // ID linked to the git instance. + InstanceId *string `pulumi:"instanceId"` + // Unique name linked to the git instance. + Name *string `pulumi:"name"` + // STACKIT project ID to which the git instance is associated. + ProjectId *string `pulumi:"projectId"` + // Url linked to the git instance. + Url *string `pulumi:"url"` + // Version linked to the git instance. + Version *string `pulumi:"version"` +} + +type GitState struct { + // ID linked to the git instance. + InstanceId pulumi.StringPtrInput + // Unique name linked to the git instance. + Name pulumi.StringPtrInput + // STACKIT project ID to which the git instance is associated. + ProjectId pulumi.StringPtrInput + // Url linked to the git instance. + Url pulumi.StringPtrInput + // Version linked to the git instance. + Version pulumi.StringPtrInput +} + +func (GitState) ElementType() reflect.Type { + return reflect.TypeOf((*gitState)(nil)).Elem() +} + +type gitArgs struct { + // Unique name linked to the git instance. + Name *string `pulumi:"name"` + // STACKIT project ID to which the git instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a Git resource. +type GitArgs struct { + // Unique name linked to the git instance. + Name pulumi.StringPtrInput + // STACKIT project ID to which the git instance is associated. + ProjectId pulumi.StringInput +} + +func (GitArgs) ElementType() reflect.Type { + return reflect.TypeOf((*gitArgs)(nil)).Elem() +} + +type GitInput interface { + pulumi.Input + + ToGitOutput() GitOutput + ToGitOutputWithContext(ctx context.Context) GitOutput +} + +func (*Git) ElementType() reflect.Type { + return reflect.TypeOf((**Git)(nil)).Elem() +} + +func (i *Git) ToGitOutput() GitOutput { + return i.ToGitOutputWithContext(context.Background()) +} + +func (i *Git) ToGitOutputWithContext(ctx context.Context) GitOutput { + return pulumi.ToOutputWithContext(ctx, i).(GitOutput) +} + +// GitArrayInput is an input type that accepts GitArray and GitArrayOutput values. +// You can construct a concrete instance of `GitArrayInput` via: +// +// GitArray{ GitArgs{...} } +type GitArrayInput interface { + pulumi.Input + + ToGitArrayOutput() GitArrayOutput + ToGitArrayOutputWithContext(context.Context) GitArrayOutput +} + +type GitArray []GitInput + +func (GitArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Git)(nil)).Elem() +} + +func (i GitArray) ToGitArrayOutput() GitArrayOutput { + return i.ToGitArrayOutputWithContext(context.Background()) +} + +func (i GitArray) ToGitArrayOutputWithContext(ctx context.Context) GitArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GitArrayOutput) +} + +// GitMapInput is an input type that accepts GitMap and GitMapOutput values. +// You can construct a concrete instance of `GitMapInput` via: +// +// GitMap{ "key": GitArgs{...} } +type GitMapInput interface { + pulumi.Input + + ToGitMapOutput() GitMapOutput + ToGitMapOutputWithContext(context.Context) GitMapOutput +} + +type GitMap map[string]GitInput + +func (GitMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Git)(nil)).Elem() +} + +func (i GitMap) ToGitMapOutput() GitMapOutput { + return i.ToGitMapOutputWithContext(context.Background()) +} + +func (i GitMap) ToGitMapOutputWithContext(ctx context.Context) GitMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(GitMapOutput) +} + +type GitOutput struct{ *pulumi.OutputState } + +func (GitOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Git)(nil)).Elem() +} + +func (o GitOutput) ToGitOutput() GitOutput { + return o +} + +func (o GitOutput) ToGitOutputWithContext(ctx context.Context) GitOutput { + return o +} + +// ID linked to the git instance. +func (o GitOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *Git) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Unique name linked to the git instance. +func (o GitOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Git) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the git instance is associated. +func (o GitOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Git) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Url linked to the git instance. +func (o GitOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *Git) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +// Version linked to the git instance. +func (o GitOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *Git) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type GitArrayOutput struct{ *pulumi.OutputState } + +func (GitArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Git)(nil)).Elem() +} + +func (o GitArrayOutput) ToGitArrayOutput() GitArrayOutput { + return o +} + +func (o GitArrayOutput) ToGitArrayOutputWithContext(ctx context.Context) GitArrayOutput { + return o +} + +func (o GitArrayOutput) Index(i pulumi.IntInput) GitOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Git { + return vs[0].([]*Git)[vs[1].(int)] + }).(GitOutput) +} + +type GitMapOutput struct{ *pulumi.OutputState } + +func (GitMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Git)(nil)).Elem() +} + +func (o GitMapOutput) ToGitMapOutput() GitMapOutput { + return o +} + +func (o GitMapOutput) ToGitMapOutputWithContext(ctx context.Context) GitMapOutput { + return o +} + +func (o GitMapOutput) MapIndex(k pulumi.StringInput) GitOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Git { + return vs[0].(map[string]*Git)[vs[1].(string)] + }).(GitOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*GitInput)(nil)).Elem(), &Git{}) + pulumi.RegisterInputType(reflect.TypeOf((*GitArrayInput)(nil)).Elem(), GitArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GitMapInput)(nil)).Elem(), GitMap{}) + pulumi.RegisterOutputType(GitOutput{}) + pulumi.RegisterOutputType(GitArrayOutput{}) + pulumi.RegisterOutputType(GitMapOutput{}) +} diff --git a/sdk/go/stackit/image.go b/sdk/go/stackit/image.go new file mode 100644 index 0000000..a6bf30f --- /dev/null +++ b/sdk/go/stackit/image.go @@ -0,0 +1,376 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Image resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type Image struct { + pulumi.CustomResourceState + + // Representation of an image checksum. + Checksum ImageChecksumOutput `pulumi:"checksum"` + // Properties to set hardware and scheduling settings for an image. + Config ImageConfigOutput `pulumi:"config"` + // The disk format of the image. + DiskFormat pulumi.StringOutput `pulumi:"diskFormat"` + // The image ID. + ImageId pulumi.StringOutput `pulumi:"imageId"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The filepath of the raw image file to be uploaded. + LocalFilePath pulumi.StringOutput `pulumi:"localFilePath"` + // The minimum disk size of the image in GB. + MinDiskSize pulumi.IntOutput `pulumi:"minDiskSize"` + // The minimum RAM of the image in MB. + MinRam pulumi.IntOutput `pulumi:"minRam"` + // The name of the image. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the image is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Whether the image is protected. + Protected pulumi.BoolOutput `pulumi:"protected"` + // The scope of the image. + Scope pulumi.StringOutput `pulumi:"scope"` +} + +// NewImage registers a new resource with the given unique name, arguments, and options. +func NewImage(ctx *pulumi.Context, + name string, args *ImageArgs, opts ...pulumi.ResourceOption) (*Image, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.DiskFormat == nil { + return nil, errors.New("invalid value for required argument 'DiskFormat'") + } + if args.LocalFilePath == nil { + return nil, errors.New("invalid value for required argument 'LocalFilePath'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Image + err := ctx.RegisterResource("stackit:index/image:Image", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetImage gets an existing Image 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 GetImage(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ImageState, opts ...pulumi.ResourceOption) (*Image, error) { + var resource Image + err := ctx.ReadResource("stackit:index/image:Image", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Image resources. +type imageState struct { + // Representation of an image checksum. + Checksum *ImageChecksum `pulumi:"checksum"` + // Properties to set hardware and scheduling settings for an image. + Config *ImageConfig `pulumi:"config"` + // The disk format of the image. + DiskFormat *string `pulumi:"diskFormat"` + // The image ID. + ImageId *string `pulumi:"imageId"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The filepath of the raw image file to be uploaded. + LocalFilePath *string `pulumi:"localFilePath"` + // The minimum disk size of the image in GB. + MinDiskSize *int `pulumi:"minDiskSize"` + // The minimum RAM of the image in MB. + MinRam *int `pulumi:"minRam"` + // The name of the image. + Name *string `pulumi:"name"` + // STACKIT project ID to which the image is associated. + ProjectId *string `pulumi:"projectId"` + // Whether the image is protected. + Protected *bool `pulumi:"protected"` + // The scope of the image. + Scope *string `pulumi:"scope"` +} + +type ImageState struct { + // Representation of an image checksum. + Checksum ImageChecksumPtrInput + // Properties to set hardware and scheduling settings for an image. + Config ImageConfigPtrInput + // The disk format of the image. + DiskFormat pulumi.StringPtrInput + // The image ID. + ImageId pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The filepath of the raw image file to be uploaded. + LocalFilePath pulumi.StringPtrInput + // The minimum disk size of the image in GB. + MinDiskSize pulumi.IntPtrInput + // The minimum RAM of the image in MB. + MinRam pulumi.IntPtrInput + // The name of the image. + Name pulumi.StringPtrInput + // STACKIT project ID to which the image is associated. + ProjectId pulumi.StringPtrInput + // Whether the image is protected. + Protected pulumi.BoolPtrInput + // The scope of the image. + Scope pulumi.StringPtrInput +} + +func (ImageState) ElementType() reflect.Type { + return reflect.TypeOf((*imageState)(nil)).Elem() +} + +type imageArgs struct { + // Properties to set hardware and scheduling settings for an image. + Config *ImageConfig `pulumi:"config"` + // The disk format of the image. + DiskFormat string `pulumi:"diskFormat"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The filepath of the raw image file to be uploaded. + LocalFilePath string `pulumi:"localFilePath"` + // The minimum disk size of the image in GB. + MinDiskSize *int `pulumi:"minDiskSize"` + // The minimum RAM of the image in MB. + MinRam *int `pulumi:"minRam"` + // The name of the image. + Name *string `pulumi:"name"` + // STACKIT project ID to which the image is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a Image resource. +type ImageArgs struct { + // Properties to set hardware and scheduling settings for an image. + Config ImageConfigPtrInput + // The disk format of the image. + DiskFormat pulumi.StringInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The filepath of the raw image file to be uploaded. + LocalFilePath pulumi.StringInput + // The minimum disk size of the image in GB. + MinDiskSize pulumi.IntPtrInput + // The minimum RAM of the image in MB. + MinRam pulumi.IntPtrInput + // The name of the image. + Name pulumi.StringPtrInput + // STACKIT project ID to which the image is associated. + ProjectId pulumi.StringInput +} + +func (ImageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*imageArgs)(nil)).Elem() +} + +type ImageInput interface { + pulumi.Input + + ToImageOutput() ImageOutput + ToImageOutputWithContext(ctx context.Context) ImageOutput +} + +func (*Image) ElementType() reflect.Type { + return reflect.TypeOf((**Image)(nil)).Elem() +} + +func (i *Image) ToImageOutput() ImageOutput { + return i.ToImageOutputWithContext(context.Background()) +} + +func (i *Image) ToImageOutputWithContext(ctx context.Context) ImageOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageOutput) +} + +// ImageArrayInput is an input type that accepts ImageArray and ImageArrayOutput values. +// You can construct a concrete instance of `ImageArrayInput` via: +// +// ImageArray{ ImageArgs{...} } +type ImageArrayInput interface { + pulumi.Input + + ToImageArrayOutput() ImageArrayOutput + ToImageArrayOutputWithContext(context.Context) ImageArrayOutput +} + +type ImageArray []ImageInput + +func (ImageArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Image)(nil)).Elem() +} + +func (i ImageArray) ToImageArrayOutput() ImageArrayOutput { + return i.ToImageArrayOutputWithContext(context.Background()) +} + +func (i ImageArray) ToImageArrayOutputWithContext(ctx context.Context) ImageArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageArrayOutput) +} + +// ImageMapInput is an input type that accepts ImageMap and ImageMapOutput values. +// You can construct a concrete instance of `ImageMapInput` via: +// +// ImageMap{ "key": ImageArgs{...} } +type ImageMapInput interface { + pulumi.Input + + ToImageMapOutput() ImageMapOutput + ToImageMapOutputWithContext(context.Context) ImageMapOutput +} + +type ImageMap map[string]ImageInput + +func (ImageMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Image)(nil)).Elem() +} + +func (i ImageMap) ToImageMapOutput() ImageMapOutput { + return i.ToImageMapOutputWithContext(context.Background()) +} + +func (i ImageMap) ToImageMapOutputWithContext(ctx context.Context) ImageMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageMapOutput) +} + +type ImageOutput struct{ *pulumi.OutputState } + +func (ImageOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Image)(nil)).Elem() +} + +func (o ImageOutput) ToImageOutput() ImageOutput { + return o +} + +func (o ImageOutput) ToImageOutputWithContext(ctx context.Context) ImageOutput { + return o +} + +// Representation of an image checksum. +func (o ImageOutput) Checksum() ImageChecksumOutput { + return o.ApplyT(func(v *Image) ImageChecksumOutput { return v.Checksum }).(ImageChecksumOutput) +} + +// Properties to set hardware and scheduling settings for an image. +func (o ImageOutput) Config() ImageConfigOutput { + return o.ApplyT(func(v *Image) ImageConfigOutput { return v.Config }).(ImageConfigOutput) +} + +// The disk format of the image. +func (o ImageOutput) DiskFormat() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.DiskFormat }).(pulumi.StringOutput) +} + +// The image ID. +func (o ImageOutput) ImageId() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.ImageId }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o ImageOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *Image) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The filepath of the raw image file to be uploaded. +func (o ImageOutput) LocalFilePath() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.LocalFilePath }).(pulumi.StringOutput) +} + +// The minimum disk size of the image in GB. +func (o ImageOutput) MinDiskSize() pulumi.IntOutput { + return o.ApplyT(func(v *Image) pulumi.IntOutput { return v.MinDiskSize }).(pulumi.IntOutput) +} + +// The minimum RAM of the image in MB. +func (o ImageOutput) MinRam() pulumi.IntOutput { + return o.ApplyT(func(v *Image) pulumi.IntOutput { return v.MinRam }).(pulumi.IntOutput) +} + +// The name of the image. +func (o ImageOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the image is associated. +func (o ImageOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Whether the image is protected. +func (o ImageOutput) Protected() pulumi.BoolOutput { + return o.ApplyT(func(v *Image) pulumi.BoolOutput { return v.Protected }).(pulumi.BoolOutput) +} + +// The scope of the image. +func (o ImageOutput) Scope() pulumi.StringOutput { + return o.ApplyT(func(v *Image) pulumi.StringOutput { return v.Scope }).(pulumi.StringOutput) +} + +type ImageArrayOutput struct{ *pulumi.OutputState } + +func (ImageArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Image)(nil)).Elem() +} + +func (o ImageArrayOutput) ToImageArrayOutput() ImageArrayOutput { + return o +} + +func (o ImageArrayOutput) ToImageArrayOutputWithContext(ctx context.Context) ImageArrayOutput { + return o +} + +func (o ImageArrayOutput) Index(i pulumi.IntInput) ImageOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Image { + return vs[0].([]*Image)[vs[1].(int)] + }).(ImageOutput) +} + +type ImageMapOutput struct{ *pulumi.OutputState } + +func (ImageMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Image)(nil)).Elem() +} + +func (o ImageMapOutput) ToImageMapOutput() ImageMapOutput { + return o +} + +func (o ImageMapOutput) ToImageMapOutputWithContext(ctx context.Context) ImageMapOutput { + return o +} + +func (o ImageMapOutput) MapIndex(k pulumi.StringInput) ImageOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Image { + return vs[0].(map[string]*Image)[vs[1].(string)] + }).(ImageOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ImageInput)(nil)).Elem(), &Image{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageArrayInput)(nil)).Elem(), ImageArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageMapInput)(nil)).Elem(), ImageMap{}) + pulumi.RegisterOutputType(ImageOutput{}) + pulumi.RegisterOutputType(ImageArrayOutput{}) + pulumi.RegisterOutputType(ImageMapOutput{}) +} diff --git a/sdk/go/stackit/init.go b/sdk/go/stackit/init.go new file mode 100644 index 0000000..d64e15a --- /dev/null +++ b/sdk/go/stackit/init.go @@ -0,0 +1,486 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "fmt" + + "github.com/blang/semver" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +type module struct { + version semver.Version +} + +func (m *module) Version() semver.Version { + return m.version +} + +func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi.Resource, err error) { + switch typ { + case "stackit:index/affinityGroup:AffinityGroup": + r = &AffinityGroup{} + case "stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment": + r = &AuthorizationOrganizationRoleAssignment{} + case "stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment": + r = &AuthorizationProjectRoleAssignment{} + case "stackit:index/cdnCustomDomain:CdnCustomDomain": + r = &CdnCustomDomain{} + case "stackit:index/cdnDistribution:CdnDistribution": + r = &CdnDistribution{} + case "stackit:index/dnsRecordSet:DnsRecordSet": + r = &DnsRecordSet{} + case "stackit:index/dnsZone:DnsZone": + r = &DnsZone{} + case "stackit:index/git:Git": + r = &Git{} + case "stackit:index/image:Image": + r = &Image{} + case "stackit:index/keyPair:KeyPair": + r = &KeyPair{} + case "stackit:index/loadbalancer:Loadbalancer": + r = &Loadbalancer{} + case "stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential": + r = &LoadbalancerObservabilityCredential{} + case "stackit:index/logmeCredential:LogmeCredential": + r = &LogmeCredential{} + case "stackit:index/logmeInstance:LogmeInstance": + r = &LogmeInstance{} + case "stackit:index/mariadbCredential:MariadbCredential": + r = &MariadbCredential{} + case "stackit:index/mariadbInstance:MariadbInstance": + r = &MariadbInstance{} + case "stackit:index/modelservingToken:ModelservingToken": + r = &ModelservingToken{} + case "stackit:index/mongodbflexInstance:MongodbflexInstance": + r = &MongodbflexInstance{} + case "stackit:index/mongodbflexUser:MongodbflexUser": + r = &MongodbflexUser{} + case "stackit:index/network:Network": + r = &Network{} + case "stackit:index/networkArea:NetworkArea": + r = &NetworkArea{} + case "stackit:index/networkAreaRoute:NetworkAreaRoute": + r = &NetworkAreaRoute{} + case "stackit:index/networkInterface:NetworkInterface": + r = &NetworkInterface{} + case "stackit:index/objectstorageBucket:ObjectstorageBucket": + r = &ObjectstorageBucket{} + case "stackit:index/objectstorageCredential:ObjectstorageCredential": + r = &ObjectstorageCredential{} + case "stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup": + r = &ObjectstorageCredentialsGroup{} + case "stackit:index/observabilityAlertgroup:ObservabilityAlertgroup": + r = &ObservabilityAlertgroup{} + case "stackit:index/observabilityCredential:ObservabilityCredential": + r = &ObservabilityCredential{} + case "stackit:index/observabilityInstance:ObservabilityInstance": + r = &ObservabilityInstance{} + case "stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup": + r = &ObservabilityLogalertgroup{} + case "stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig": + r = &ObservabilityScrapeconfig{} + case "stackit:index/opensearchCredential:OpensearchCredential": + r = &OpensearchCredential{} + case "stackit:index/opensearchInstance:OpensearchInstance": + r = &OpensearchInstance{} + case "stackit:index/postgresflexDatabase:PostgresflexDatabase": + r = &PostgresflexDatabase{} + case "stackit:index/postgresflexInstance:PostgresflexInstance": + r = &PostgresflexInstance{} + case "stackit:index/postgresflexUser:PostgresflexUser": + r = &PostgresflexUser{} + case "stackit:index/publicIp:PublicIp": + r = &PublicIp{} + case "stackit:index/publicIpAssociate:PublicIpAssociate": + r = &PublicIpAssociate{} + case "stackit:index/rabbitmqCredential:RabbitmqCredential": + r = &RabbitmqCredential{} + case "stackit:index/rabbitmqInstance:RabbitmqInstance": + r = &RabbitmqInstance{} + case "stackit:index/redisCredential:RedisCredential": + r = &RedisCredential{} + case "stackit:index/redisInstance:RedisInstance": + r = &RedisInstance{} + case "stackit:index/resourcemanagerProject:ResourcemanagerProject": + r = &ResourcemanagerProject{} + case "stackit:index/secretsmanagerInstance:SecretsmanagerInstance": + r = &SecretsmanagerInstance{} + case "stackit:index/secretsmanagerUser:SecretsmanagerUser": + r = &SecretsmanagerUser{} + case "stackit:index/securityGroup:SecurityGroup": + r = &SecurityGroup{} + case "stackit:index/securityGroupRule:SecurityGroupRule": + r = &SecurityGroupRule{} + case "stackit:index/server:Server": + r = &Server{} + case "stackit:index/serverBackupSchedule:ServerBackupSchedule": + r = &ServerBackupSchedule{} + case "stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach": + r = &ServerNetworkInterfaceAttach{} + case "stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach": + r = &ServerServiceAccountAttach{} + case "stackit:index/serverUpdateSchedule:ServerUpdateSchedule": + r = &ServerUpdateSchedule{} + case "stackit:index/serverVolumeAttach:ServerVolumeAttach": + r = &ServerVolumeAttach{} + case "stackit:index/serviceAccount:ServiceAccount": + r = &ServiceAccount{} + case "stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken": + r = &ServiceAccountAccessToken{} + case "stackit:index/serviceAccountKey:ServiceAccountKey": + r = &ServiceAccountKey{} + case "stackit:index/skeCluster:SkeCluster": + r = &SkeCluster{} + case "stackit:index/skeKubeconfig:SkeKubeconfig": + r = &SkeKubeconfig{} + case "stackit:index/sqlserverflexInstance:SqlserverflexInstance": + r = &SqlserverflexInstance{} + case "stackit:index/sqlserverflexUser:SqlserverflexUser": + r = &SqlserverflexUser{} + case "stackit:index/volume:Volume": + r = &Volume{} + default: + return nil, fmt.Errorf("unknown resource type: %s", typ) + } + + err = ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn)) + return +} + +type pkg struct { + version semver.Version +} + +func (p *pkg) Version() semver.Version { + return p.version +} + +func (p *pkg) ConstructProvider(ctx *pulumi.Context, name, typ, urn string) (pulumi.ProviderResource, error) { + if typ != "pulumi:providers:stackit" { + return nil, fmt.Errorf("unknown provider type: %s", typ) + } + + r := &Provider{} + err := ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn)) + return r, err +} + +func init() { + version, err := internal.PkgVersion() + if err != nil { + version = semver.Version{Major: 1} + } + pulumi.RegisterResourceModule( + "stackit", + "index/affinityGroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/authorizationOrganizationRoleAssignment", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/authorizationProjectRoleAssignment", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/cdnCustomDomain", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/cdnDistribution", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/dnsRecordSet", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/dnsZone", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/git", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/image", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/keyPair", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/loadbalancer", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/loadbalancerObservabilityCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/logmeCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/logmeInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/mariadbCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/mariadbInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/modelservingToken", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/mongodbflexInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/mongodbflexUser", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/network", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/networkArea", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/networkAreaRoute", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/networkInterface", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/objectstorageBucket", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/objectstorageCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/objectstorageCredentialsGroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/observabilityAlertgroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/observabilityCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/observabilityInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/observabilityLogalertgroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/observabilityScrapeconfig", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/opensearchCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/opensearchInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/postgresflexDatabase", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/postgresflexInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/postgresflexUser", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/publicIp", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/publicIpAssociate", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/rabbitmqCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/rabbitmqInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/redisCredential", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/redisInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/resourcemanagerProject", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/secretsmanagerInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/secretsmanagerUser", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/securityGroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/securityGroupRule", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/server", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serverBackupSchedule", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serverNetworkInterfaceAttach", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serverServiceAccountAttach", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serverUpdateSchedule", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serverVolumeAttach", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serviceAccount", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serviceAccountAccessToken", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/serviceAccountKey", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/skeCluster", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/skeKubeconfig", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/sqlserverflexInstance", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/sqlserverflexUser", + &module{version}, + ) + pulumi.RegisterResourceModule( + "stackit", + "index/volume", + &module{version}, + ) + pulumi.RegisterResourcePackage( + "stackit", + &pkg{version}, + ) +} diff --git a/sdk/go/stackit/internal/pulumiUtilities.go b/sdk/go/stackit/internal/pulumiUtilities.go new file mode 100644 index 0000000..25627ba --- /dev/null +++ b/sdk/go/stackit/internal/pulumiUtilities.go @@ -0,0 +1,184 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package internal + +import ( + "fmt" + "os" + "reflect" + "regexp" + "strconv" + "strings" + + "github.com/blang/semver" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +import ( + "github.com/pulumi/pulumi/sdk/v3/go/pulumi/internals" +) + +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, ok := os.LookupEnv(v); ok { + 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) { + // 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-stackit/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() +} + +func CallPlain( + ctx *pulumi.Context, + tok string, + args pulumi.Input, + output pulumi.Output, + self pulumi.Resource, + property string, + resultPtr reflect.Value, + errorPtr *error, + opts ...pulumi.InvokeOption, +) { + res, err := callPlainInner(ctx, tok, args, output, self, opts...) + if err != nil { + *errorPtr = err + return + } + + v := reflect.ValueOf(res) + + // extract res.property field if asked to do so + if property != "" { + v = v.FieldByName("Res") + } + + // return by setting the result pointer; this style of returns shortens the generated code without generics + resultPtr.Elem().Set(v) +} + +func callPlainInner( + ctx *pulumi.Context, + tok string, + args pulumi.Input, + output pulumi.Output, + self pulumi.Resource, + opts ...pulumi.InvokeOption, +) (any, error) { + o, err := ctx.Call(tok, args, output, self, opts...) + if err != nil { + return nil, err + } + + outputData, err := internals.UnsafeAwaitOutput(ctx.Context(), o) + if err != nil { + return nil, err + } + + // Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency. + known := outputData.Known + value := outputData.Value + secret := outputData.Secret + + problem := "" + if !known { + problem = "an unknown value" + } else if secret { + problem = "a secret value" + } + + if problem != "" { + return nil, fmt.Errorf("Plain resource method %q incorrectly returned %s. "+ + "This is an error in the provider, please report this to the provider developer.", + tok, problem) + } + + return value, nil +} + +// PkgResourceDefaultOpts provides package level defaults to pulumi.OptionResource. +func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption { + defaults := []pulumi.ResourceOption{} + defaults = append(defaults, pulumi.PluginDownloadURL("github://api.github.com/stackitcloud/pulumi-stackit")) + 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{} + defaults = append(defaults, pulumi.PluginDownloadURL("github://api.github.com/stackitcloud/pulumi-stackit")) + version := SdkVersion + if !version.Equals(semver.Version{}) { + defaults = append(defaults, pulumi.Version(version.String())) + } + return append(defaults, opts...) +} diff --git a/sdk/go/stackit/internal/pulumiVersion.go b/sdk/go/stackit/internal/pulumiVersion.go new file mode 100644 index 0000000..4ad7cb8 --- /dev/null +++ b/sdk/go/stackit/internal/pulumiVersion.go @@ -0,0 +1,11 @@ +// Code generated by pulumi-language-go 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/stackit/keyPair.go b/sdk/go/stackit/keyPair.go new file mode 100644 index 0000000..249de77 --- /dev/null +++ b/sdk/go/stackit/keyPair.go @@ -0,0 +1,260 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication. +type KeyPair struct { + pulumi.CustomResourceState + + // The fingerprint of the public SSH key. + Fingerprint pulumi.StringOutput `pulumi:"fingerprint"` + // Labels are key-value string pairs which can be attached to a resource container. + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The name of the SSH key pair. + Name pulumi.StringOutput `pulumi:"name"` + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey pulumi.StringOutput `pulumi:"publicKey"` +} + +// NewKeyPair registers a new resource with the given unique name, arguments, and options. +func NewKeyPair(ctx *pulumi.Context, + name string, args *KeyPairArgs, opts ...pulumi.ResourceOption) (*KeyPair, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PublicKey == nil { + return nil, errors.New("invalid value for required argument 'PublicKey'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource KeyPair + err := ctx.RegisterResource("stackit:index/keyPair:KeyPair", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetKeyPair gets an existing KeyPair 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 GetKeyPair(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *KeyPairState, opts ...pulumi.ResourceOption) (*KeyPair, error) { + var resource KeyPair + err := ctx.ReadResource("stackit:index/keyPair:KeyPair", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering KeyPair resources. +type keyPairState struct { + // The fingerprint of the public SSH key. + Fingerprint *string `pulumi:"fingerprint"` + // Labels are key-value string pairs which can be attached to a resource container. + Labels map[string]string `pulumi:"labels"` + // The name of the SSH key pair. + Name *string `pulumi:"name"` + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey *string `pulumi:"publicKey"` +} + +type KeyPairState struct { + // The fingerprint of the public SSH key. + Fingerprint pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container. + Labels pulumi.StringMapInput + // The name of the SSH key pair. + Name pulumi.StringPtrInput + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey pulumi.StringPtrInput +} + +func (KeyPairState) ElementType() reflect.Type { + return reflect.TypeOf((*keyPairState)(nil)).Elem() +} + +type keyPairArgs struct { + // Labels are key-value string pairs which can be attached to a resource container. + Labels map[string]string `pulumi:"labels"` + // The name of the SSH key pair. + Name *string `pulumi:"name"` + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey string `pulumi:"publicKey"` +} + +// The set of arguments for constructing a KeyPair resource. +type KeyPairArgs struct { + // Labels are key-value string pairs which can be attached to a resource container. + Labels pulumi.StringMapInput + // The name of the SSH key pair. + Name pulumi.StringPtrInput + // A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + PublicKey pulumi.StringInput +} + +func (KeyPairArgs) ElementType() reflect.Type { + return reflect.TypeOf((*keyPairArgs)(nil)).Elem() +} + +type KeyPairInput interface { + pulumi.Input + + ToKeyPairOutput() KeyPairOutput + ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput +} + +func (*KeyPair) ElementType() reflect.Type { + return reflect.TypeOf((**KeyPair)(nil)).Elem() +} + +func (i *KeyPair) ToKeyPairOutput() KeyPairOutput { + return i.ToKeyPairOutputWithContext(context.Background()) +} + +func (i *KeyPair) ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput { + return pulumi.ToOutputWithContext(ctx, i).(KeyPairOutput) +} + +// KeyPairArrayInput is an input type that accepts KeyPairArray and KeyPairArrayOutput values. +// You can construct a concrete instance of `KeyPairArrayInput` via: +// +// KeyPairArray{ KeyPairArgs{...} } +type KeyPairArrayInput interface { + pulumi.Input + + ToKeyPairArrayOutput() KeyPairArrayOutput + ToKeyPairArrayOutputWithContext(context.Context) KeyPairArrayOutput +} + +type KeyPairArray []KeyPairInput + +func (KeyPairArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*KeyPair)(nil)).Elem() +} + +func (i KeyPairArray) ToKeyPairArrayOutput() KeyPairArrayOutput { + return i.ToKeyPairArrayOutputWithContext(context.Background()) +} + +func (i KeyPairArray) ToKeyPairArrayOutputWithContext(ctx context.Context) KeyPairArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(KeyPairArrayOutput) +} + +// KeyPairMapInput is an input type that accepts KeyPairMap and KeyPairMapOutput values. +// You can construct a concrete instance of `KeyPairMapInput` via: +// +// KeyPairMap{ "key": KeyPairArgs{...} } +type KeyPairMapInput interface { + pulumi.Input + + ToKeyPairMapOutput() KeyPairMapOutput + ToKeyPairMapOutputWithContext(context.Context) KeyPairMapOutput +} + +type KeyPairMap map[string]KeyPairInput + +func (KeyPairMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*KeyPair)(nil)).Elem() +} + +func (i KeyPairMap) ToKeyPairMapOutput() KeyPairMapOutput { + return i.ToKeyPairMapOutputWithContext(context.Background()) +} + +func (i KeyPairMap) ToKeyPairMapOutputWithContext(ctx context.Context) KeyPairMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(KeyPairMapOutput) +} + +type KeyPairOutput struct{ *pulumi.OutputState } + +func (KeyPairOutput) ElementType() reflect.Type { + return reflect.TypeOf((**KeyPair)(nil)).Elem() +} + +func (o KeyPairOutput) ToKeyPairOutput() KeyPairOutput { + return o +} + +func (o KeyPairOutput) ToKeyPairOutputWithContext(ctx context.Context) KeyPairOutput { + return o +} + +// The fingerprint of the public SSH key. +func (o KeyPairOutput) Fingerprint() pulumi.StringOutput { + return o.ApplyT(func(v *KeyPair) pulumi.StringOutput { return v.Fingerprint }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container. +func (o KeyPairOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *KeyPair) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the SSH key pair. +func (o KeyPairOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *KeyPair) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. +func (o KeyPairOutput) PublicKey() pulumi.StringOutput { + return o.ApplyT(func(v *KeyPair) pulumi.StringOutput { return v.PublicKey }).(pulumi.StringOutput) +} + +type KeyPairArrayOutput struct{ *pulumi.OutputState } + +func (KeyPairArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*KeyPair)(nil)).Elem() +} + +func (o KeyPairArrayOutput) ToKeyPairArrayOutput() KeyPairArrayOutput { + return o +} + +func (o KeyPairArrayOutput) ToKeyPairArrayOutputWithContext(ctx context.Context) KeyPairArrayOutput { + return o +} + +func (o KeyPairArrayOutput) Index(i pulumi.IntInput) KeyPairOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *KeyPair { + return vs[0].([]*KeyPair)[vs[1].(int)] + }).(KeyPairOutput) +} + +type KeyPairMapOutput struct{ *pulumi.OutputState } + +func (KeyPairMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*KeyPair)(nil)).Elem() +} + +func (o KeyPairMapOutput) ToKeyPairMapOutput() KeyPairMapOutput { + return o +} + +func (o KeyPairMapOutput) ToKeyPairMapOutputWithContext(ctx context.Context) KeyPairMapOutput { + return o +} + +func (o KeyPairMapOutput) MapIndex(k pulumi.StringInput) KeyPairOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *KeyPair { + return vs[0].(map[string]*KeyPair)[vs[1].(string)] + }).(KeyPairOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*KeyPairInput)(nil)).Elem(), &KeyPair{}) + pulumi.RegisterInputType(reflect.TypeOf((*KeyPairArrayInput)(nil)).Elem(), KeyPairArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*KeyPairMapInput)(nil)).Elem(), KeyPairMap{}) + pulumi.RegisterOutputType(KeyPairOutput{}) + pulumi.RegisterOutputType(KeyPairArrayOutput{}) + pulumi.RegisterOutputType(KeyPairMapOutput{}) +} diff --git a/sdk/go/stackit/loadbalancer.go b/sdk/go/stackit/loadbalancer.go new file mode 100644 index 0000000..c0e990d --- /dev/null +++ b/sdk/go/stackit/loadbalancer.go @@ -0,0 +1,344 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ## Example Usage +type Loadbalancer struct { + pulumi.CustomResourceState + + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress pulumi.StringPtrOutput `pulumi:"externalAddress"` + // List of all listeners which will accept traffic. Limited to 20. + Listeners LoadbalancerListenerArrayOutput `pulumi:"listeners"` + // Load balancer name. + Name pulumi.StringOutput `pulumi:"name"` + // List of networks that listeners and targets reside in. + Networks LoadbalancerNetworkArrayOutput `pulumi:"networks"` + // Defines any optional functionality you want to have enabled on your load balancer. + Options LoadbalancerOptionsOutput `pulumi:"options"` + // Transient private Load Balancer IP address. It can change any time. + PrivateAddress pulumi.StringOutput `pulumi:"privateAddress"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools LoadbalancerTargetPoolArrayOutput `pulumi:"targetPools"` +} + +// NewLoadbalancer registers a new resource with the given unique name, arguments, and options. +func NewLoadbalancer(ctx *pulumi.Context, + name string, args *LoadbalancerArgs, opts ...pulumi.ResourceOption) (*Loadbalancer, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Listeners == nil { + return nil, errors.New("invalid value for required argument 'Listeners'") + } + if args.Networks == nil { + return nil, errors.New("invalid value for required argument 'Networks'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.TargetPools == nil { + return nil, errors.New("invalid value for required argument 'TargetPools'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Loadbalancer + err := ctx.RegisterResource("stackit:index/loadbalancer:Loadbalancer", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetLoadbalancer gets an existing Loadbalancer 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 GetLoadbalancer(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *LoadbalancerState, opts ...pulumi.ResourceOption) (*Loadbalancer, error) { + var resource Loadbalancer + err := ctx.ReadResource("stackit:index/loadbalancer:Loadbalancer", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Loadbalancer resources. +type loadbalancerState struct { + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress *string `pulumi:"externalAddress"` + // List of all listeners which will accept traffic. Limited to 20. + Listeners []LoadbalancerListener `pulumi:"listeners"` + // Load balancer name. + Name *string `pulumi:"name"` + // List of networks that listeners and targets reside in. + Networks []LoadbalancerNetwork `pulumi:"networks"` + // Defines any optional functionality you want to have enabled on your load balancer. + Options *LoadbalancerOptions `pulumi:"options"` + // Transient private Load Balancer IP address. It can change any time. + PrivateAddress *string `pulumi:"privateAddress"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools []LoadbalancerTargetPool `pulumi:"targetPools"` +} + +type LoadbalancerState struct { + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress pulumi.StringPtrInput + // List of all listeners which will accept traffic. Limited to 20. + Listeners LoadbalancerListenerArrayInput + // Load balancer name. + Name pulumi.StringPtrInput + // List of networks that listeners and targets reside in. + Networks LoadbalancerNetworkArrayInput + // Defines any optional functionality you want to have enabled on your load balancer. + Options LoadbalancerOptionsPtrInput + // Transient private Load Balancer IP address. It can change any time. + PrivateAddress pulumi.StringPtrInput + // STACKIT project ID to which the Load Balancer is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools LoadbalancerTargetPoolArrayInput +} + +func (LoadbalancerState) ElementType() reflect.Type { + return reflect.TypeOf((*loadbalancerState)(nil)).Elem() +} + +type loadbalancerArgs struct { + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress *string `pulumi:"externalAddress"` + // List of all listeners which will accept traffic. Limited to 20. + Listeners []LoadbalancerListener `pulumi:"listeners"` + // Load balancer name. + Name *string `pulumi:"name"` + // List of networks that listeners and targets reside in. + Networks []LoadbalancerNetwork `pulumi:"networks"` + // Defines any optional functionality you want to have enabled on your load balancer. + Options *LoadbalancerOptions `pulumi:"options"` + // STACKIT project ID to which the Load Balancer is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools []LoadbalancerTargetPool `pulumi:"targetPools"` +} + +// The set of arguments for constructing a Loadbalancer resource. +type LoadbalancerArgs struct { + // External Load Balancer IP address where this Load Balancer is exposed. + ExternalAddress pulumi.StringPtrInput + // List of all listeners which will accept traffic. Limited to 20. + Listeners LoadbalancerListenerArrayInput + // Load balancer name. + Name pulumi.StringPtrInput + // List of networks that listeners and targets reside in. + Networks LoadbalancerNetworkArrayInput + // Defines any optional functionality you want to have enabled on your load balancer. + Options LoadbalancerOptionsPtrInput + // STACKIT project ID to which the Load Balancer is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // List of all target pools which will be used in the Load Balancer. Limited to 20. + TargetPools LoadbalancerTargetPoolArrayInput +} + +func (LoadbalancerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*loadbalancerArgs)(nil)).Elem() +} + +type LoadbalancerInput interface { + pulumi.Input + + ToLoadbalancerOutput() LoadbalancerOutput + ToLoadbalancerOutputWithContext(ctx context.Context) LoadbalancerOutput +} + +func (*Loadbalancer) ElementType() reflect.Type { + return reflect.TypeOf((**Loadbalancer)(nil)).Elem() +} + +func (i *Loadbalancer) ToLoadbalancerOutput() LoadbalancerOutput { + return i.ToLoadbalancerOutputWithContext(context.Background()) +} + +func (i *Loadbalancer) ToLoadbalancerOutputWithContext(ctx context.Context) LoadbalancerOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOutput) +} + +// LoadbalancerArrayInput is an input type that accepts LoadbalancerArray and LoadbalancerArrayOutput values. +// You can construct a concrete instance of `LoadbalancerArrayInput` via: +// +// LoadbalancerArray{ LoadbalancerArgs{...} } +type LoadbalancerArrayInput interface { + pulumi.Input + + ToLoadbalancerArrayOutput() LoadbalancerArrayOutput + ToLoadbalancerArrayOutputWithContext(context.Context) LoadbalancerArrayOutput +} + +type LoadbalancerArray []LoadbalancerInput + +func (LoadbalancerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Loadbalancer)(nil)).Elem() +} + +func (i LoadbalancerArray) ToLoadbalancerArrayOutput() LoadbalancerArrayOutput { + return i.ToLoadbalancerArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerArray) ToLoadbalancerArrayOutputWithContext(ctx context.Context) LoadbalancerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerArrayOutput) +} + +// LoadbalancerMapInput is an input type that accepts LoadbalancerMap and LoadbalancerMapOutput values. +// You can construct a concrete instance of `LoadbalancerMapInput` via: +// +// LoadbalancerMap{ "key": LoadbalancerArgs{...} } +type LoadbalancerMapInput interface { + pulumi.Input + + ToLoadbalancerMapOutput() LoadbalancerMapOutput + ToLoadbalancerMapOutputWithContext(context.Context) LoadbalancerMapOutput +} + +type LoadbalancerMap map[string]LoadbalancerInput + +func (LoadbalancerMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Loadbalancer)(nil)).Elem() +} + +func (i LoadbalancerMap) ToLoadbalancerMapOutput() LoadbalancerMapOutput { + return i.ToLoadbalancerMapOutputWithContext(context.Background()) +} + +func (i LoadbalancerMap) ToLoadbalancerMapOutputWithContext(ctx context.Context) LoadbalancerMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerMapOutput) +} + +type LoadbalancerOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Loadbalancer)(nil)).Elem() +} + +func (o LoadbalancerOutput) ToLoadbalancerOutput() LoadbalancerOutput { + return o +} + +func (o LoadbalancerOutput) ToLoadbalancerOutputWithContext(ctx context.Context) LoadbalancerOutput { + return o +} + +// External Load Balancer IP address where this Load Balancer is exposed. +func (o LoadbalancerOutput) ExternalAddress() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Loadbalancer) pulumi.StringPtrOutput { return v.ExternalAddress }).(pulumi.StringPtrOutput) +} + +// List of all listeners which will accept traffic. Limited to 20. +func (o LoadbalancerOutput) Listeners() LoadbalancerListenerArrayOutput { + return o.ApplyT(func(v *Loadbalancer) LoadbalancerListenerArrayOutput { return v.Listeners }).(LoadbalancerListenerArrayOutput) +} + +// Load balancer name. +func (o LoadbalancerOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Loadbalancer) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// List of networks that listeners and targets reside in. +func (o LoadbalancerOutput) Networks() LoadbalancerNetworkArrayOutput { + return o.ApplyT(func(v *Loadbalancer) LoadbalancerNetworkArrayOutput { return v.Networks }).(LoadbalancerNetworkArrayOutput) +} + +// Defines any optional functionality you want to have enabled on your load balancer. +func (o LoadbalancerOutput) Options() LoadbalancerOptionsOutput { + return o.ApplyT(func(v *Loadbalancer) LoadbalancerOptionsOutput { return v.Options }).(LoadbalancerOptionsOutput) +} + +// Transient private Load Balancer IP address. It can change any time. +func (o LoadbalancerOutput) PrivateAddress() pulumi.StringOutput { + return o.ApplyT(func(v *Loadbalancer) pulumi.StringOutput { return v.PrivateAddress }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the Load Balancer is associated. +func (o LoadbalancerOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Loadbalancer) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LoadbalancerOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *Loadbalancer) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// List of all target pools which will be used in the Load Balancer. Limited to 20. +func (o LoadbalancerOutput) TargetPools() LoadbalancerTargetPoolArrayOutput { + return o.ApplyT(func(v *Loadbalancer) LoadbalancerTargetPoolArrayOutput { return v.TargetPools }).(LoadbalancerTargetPoolArrayOutput) +} + +type LoadbalancerArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Loadbalancer)(nil)).Elem() +} + +func (o LoadbalancerArrayOutput) ToLoadbalancerArrayOutput() LoadbalancerArrayOutput { + return o +} + +func (o LoadbalancerArrayOutput) ToLoadbalancerArrayOutputWithContext(ctx context.Context) LoadbalancerArrayOutput { + return o +} + +func (o LoadbalancerArrayOutput) Index(i pulumi.IntInput) LoadbalancerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Loadbalancer { + return vs[0].([]*Loadbalancer)[vs[1].(int)] + }).(LoadbalancerOutput) +} + +type LoadbalancerMapOutput struct{ *pulumi.OutputState } + +func (LoadbalancerMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Loadbalancer)(nil)).Elem() +} + +func (o LoadbalancerMapOutput) ToLoadbalancerMapOutput() LoadbalancerMapOutput { + return o +} + +func (o LoadbalancerMapOutput) ToLoadbalancerMapOutputWithContext(ctx context.Context) LoadbalancerMapOutput { + return o +} + +func (o LoadbalancerMapOutput) MapIndex(k pulumi.StringInput) LoadbalancerOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Loadbalancer { + return vs[0].(map[string]*Loadbalancer)[vs[1].(string)] + }).(LoadbalancerOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerInput)(nil)).Elem(), &Loadbalancer{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerArrayInput)(nil)).Elem(), LoadbalancerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerMapInput)(nil)).Elem(), LoadbalancerMap{}) + pulumi.RegisterOutputType(LoadbalancerOutput{}) + pulumi.RegisterOutputType(LoadbalancerArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerMapOutput{}) +} diff --git a/sdk/go/stackit/loadbalancerObservabilityCredential.go b/sdk/go/stackit/loadbalancerObservabilityCredential.go new file mode 100644 index 0000000..e58a637 --- /dev/null +++ b/sdk/go/stackit/loadbalancerObservabilityCredential.go @@ -0,0 +1,301 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into +// +// ## Example Usage +type LoadbalancerObservabilityCredential struct { + pulumi.CustomResourceState + + // The credentials reference is used by the Load Balancer to define which credentials it will use. + CredentialsRef pulumi.StringOutput `pulumi:"credentialsRef"` + // Observability credential name. + DisplayName pulumi.StringOutput `pulumi:"displayName"` + // The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Password pulumi.StringOutput `pulumi:"password"` + // STACKIT project ID to which the load balancer observability credential is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewLoadbalancerObservabilityCredential registers a new resource with the given unique name, arguments, and options. +func NewLoadbalancerObservabilityCredential(ctx *pulumi.Context, + name string, args *LoadbalancerObservabilityCredentialArgs, opts ...pulumi.ResourceOption) (*LoadbalancerObservabilityCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.DisplayName == nil { + return nil, errors.New("invalid value for required argument 'DisplayName'") + } + if args.Password == nil { + return nil, errors.New("invalid value for required argument 'Password'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource LoadbalancerObservabilityCredential + err := ctx.RegisterResource("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetLoadbalancerObservabilityCredential gets an existing LoadbalancerObservabilityCredential 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 GetLoadbalancerObservabilityCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *LoadbalancerObservabilityCredentialState, opts ...pulumi.ResourceOption) (*LoadbalancerObservabilityCredential, error) { + var resource LoadbalancerObservabilityCredential + err := ctx.ReadResource("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering LoadbalancerObservabilityCredential resources. +type loadbalancerObservabilityCredentialState struct { + // The credentials reference is used by the Load Balancer to define which credentials it will use. + CredentialsRef *string `pulumi:"credentialsRef"` + // Observability credential name. + DisplayName *string `pulumi:"displayName"` + // The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Password *string `pulumi:"password"` + // STACKIT project ID to which the load balancer observability credential is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Username *string `pulumi:"username"` +} + +type LoadbalancerObservabilityCredentialState struct { + // The credentials reference is used by the Load Balancer to define which credentials it will use. + CredentialsRef pulumi.StringPtrInput + // Observability credential name. + DisplayName pulumi.StringPtrInput + // The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Password pulumi.StringPtrInput + // STACKIT project ID to which the load balancer observability credential is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Username pulumi.StringPtrInput +} + +func (LoadbalancerObservabilityCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*loadbalancerObservabilityCredentialState)(nil)).Elem() +} + +type loadbalancerObservabilityCredentialArgs struct { + // Observability credential name. + DisplayName string `pulumi:"displayName"` + // The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Password string `pulumi:"password"` + // STACKIT project ID to which the load balancer observability credential is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a LoadbalancerObservabilityCredential resource. +type LoadbalancerObservabilityCredentialArgs struct { + // Observability credential name. + DisplayName pulumi.StringInput + // The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Password pulumi.StringInput + // STACKIT project ID to which the load balancer observability credential is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + Username pulumi.StringInput +} + +func (LoadbalancerObservabilityCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*loadbalancerObservabilityCredentialArgs)(nil)).Elem() +} + +type LoadbalancerObservabilityCredentialInput interface { + pulumi.Input + + ToLoadbalancerObservabilityCredentialOutput() LoadbalancerObservabilityCredentialOutput + ToLoadbalancerObservabilityCredentialOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialOutput +} + +func (*LoadbalancerObservabilityCredential) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (i *LoadbalancerObservabilityCredential) ToLoadbalancerObservabilityCredentialOutput() LoadbalancerObservabilityCredentialOutput { + return i.ToLoadbalancerObservabilityCredentialOutputWithContext(context.Background()) +} + +func (i *LoadbalancerObservabilityCredential) ToLoadbalancerObservabilityCredentialOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerObservabilityCredentialOutput) +} + +// LoadbalancerObservabilityCredentialArrayInput is an input type that accepts LoadbalancerObservabilityCredentialArray and LoadbalancerObservabilityCredentialArrayOutput values. +// You can construct a concrete instance of `LoadbalancerObservabilityCredentialArrayInput` via: +// +// LoadbalancerObservabilityCredentialArray{ LoadbalancerObservabilityCredentialArgs{...} } +type LoadbalancerObservabilityCredentialArrayInput interface { + pulumi.Input + + ToLoadbalancerObservabilityCredentialArrayOutput() LoadbalancerObservabilityCredentialArrayOutput + ToLoadbalancerObservabilityCredentialArrayOutputWithContext(context.Context) LoadbalancerObservabilityCredentialArrayOutput +} + +type LoadbalancerObservabilityCredentialArray []LoadbalancerObservabilityCredentialInput + +func (LoadbalancerObservabilityCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (i LoadbalancerObservabilityCredentialArray) ToLoadbalancerObservabilityCredentialArrayOutput() LoadbalancerObservabilityCredentialArrayOutput { + return i.ToLoadbalancerObservabilityCredentialArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerObservabilityCredentialArray) ToLoadbalancerObservabilityCredentialArrayOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerObservabilityCredentialArrayOutput) +} + +// LoadbalancerObservabilityCredentialMapInput is an input type that accepts LoadbalancerObservabilityCredentialMap and LoadbalancerObservabilityCredentialMapOutput values. +// You can construct a concrete instance of `LoadbalancerObservabilityCredentialMapInput` via: +// +// LoadbalancerObservabilityCredentialMap{ "key": LoadbalancerObservabilityCredentialArgs{...} } +type LoadbalancerObservabilityCredentialMapInput interface { + pulumi.Input + + ToLoadbalancerObservabilityCredentialMapOutput() LoadbalancerObservabilityCredentialMapOutput + ToLoadbalancerObservabilityCredentialMapOutputWithContext(context.Context) LoadbalancerObservabilityCredentialMapOutput +} + +type LoadbalancerObservabilityCredentialMap map[string]LoadbalancerObservabilityCredentialInput + +func (LoadbalancerObservabilityCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (i LoadbalancerObservabilityCredentialMap) ToLoadbalancerObservabilityCredentialMapOutput() LoadbalancerObservabilityCredentialMapOutput { + return i.ToLoadbalancerObservabilityCredentialMapOutputWithContext(context.Background()) +} + +func (i LoadbalancerObservabilityCredentialMap) ToLoadbalancerObservabilityCredentialMapOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerObservabilityCredentialMapOutput) +} + +type LoadbalancerObservabilityCredentialOutput struct{ *pulumi.OutputState } + +func (LoadbalancerObservabilityCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (o LoadbalancerObservabilityCredentialOutput) ToLoadbalancerObservabilityCredentialOutput() LoadbalancerObservabilityCredentialOutput { + return o +} + +func (o LoadbalancerObservabilityCredentialOutput) ToLoadbalancerObservabilityCredentialOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialOutput { + return o +} + +// The credentials reference is used by the Load Balancer to define which credentials it will use. +func (o LoadbalancerObservabilityCredentialOutput) CredentialsRef() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.CredentialsRef }).(pulumi.StringOutput) +} + +// Observability credential name. +func (o LoadbalancerObservabilityCredentialOutput) DisplayName() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.DisplayName }).(pulumi.StringOutput) +} + +// The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. +func (o LoadbalancerObservabilityCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the load balancer observability credential is associated. +func (o LoadbalancerObservabilityCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o LoadbalancerObservabilityCredentialOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. +func (o LoadbalancerObservabilityCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *LoadbalancerObservabilityCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type LoadbalancerObservabilityCredentialArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerObservabilityCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (o LoadbalancerObservabilityCredentialArrayOutput) ToLoadbalancerObservabilityCredentialArrayOutput() LoadbalancerObservabilityCredentialArrayOutput { + return o +} + +func (o LoadbalancerObservabilityCredentialArrayOutput) ToLoadbalancerObservabilityCredentialArrayOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialArrayOutput { + return o +} + +func (o LoadbalancerObservabilityCredentialArrayOutput) Index(i pulumi.IntInput) LoadbalancerObservabilityCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LoadbalancerObservabilityCredential { + return vs[0].([]*LoadbalancerObservabilityCredential)[vs[1].(int)] + }).(LoadbalancerObservabilityCredentialOutput) +} + +type LoadbalancerObservabilityCredentialMapOutput struct{ *pulumi.OutputState } + +func (LoadbalancerObservabilityCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LoadbalancerObservabilityCredential)(nil)).Elem() +} + +func (o LoadbalancerObservabilityCredentialMapOutput) ToLoadbalancerObservabilityCredentialMapOutput() LoadbalancerObservabilityCredentialMapOutput { + return o +} + +func (o LoadbalancerObservabilityCredentialMapOutput) ToLoadbalancerObservabilityCredentialMapOutputWithContext(ctx context.Context) LoadbalancerObservabilityCredentialMapOutput { + return o +} + +func (o LoadbalancerObservabilityCredentialMapOutput) MapIndex(k pulumi.StringInput) LoadbalancerObservabilityCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LoadbalancerObservabilityCredential { + return vs[0].(map[string]*LoadbalancerObservabilityCredential)[vs[1].(string)] + }).(LoadbalancerObservabilityCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerObservabilityCredentialInput)(nil)).Elem(), &LoadbalancerObservabilityCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerObservabilityCredentialArrayInput)(nil)).Elem(), LoadbalancerObservabilityCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerObservabilityCredentialMapInput)(nil)).Elem(), LoadbalancerObservabilityCredentialMap{}) + pulumi.RegisterOutputType(LoadbalancerObservabilityCredentialOutput{}) + pulumi.RegisterOutputType(LoadbalancerObservabilityCredentialArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerObservabilityCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/logmeCredential.go b/sdk/go/stackit/logmeCredential.go new file mode 100644 index 0000000..7ed9f09 --- /dev/null +++ b/sdk/go/stackit/logmeCredential.go @@ -0,0 +1,290 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// LogMe credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type LogmeCredential struct { + pulumi.CustomResourceState + + // The credential's ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + Host pulumi.StringOutput `pulumi:"host"` + // ID of the LogMe instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Uri pulumi.StringOutput `pulumi:"uri"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewLogmeCredential registers a new resource with the given unique name, arguments, and options. +func NewLogmeCredential(ctx *pulumi.Context, + name string, args *LogmeCredentialArgs, opts ...pulumi.ResourceOption) (*LogmeCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource LogmeCredential + err := ctx.RegisterResource("stackit:index/logmeCredential:LogmeCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetLogmeCredential gets an existing LogmeCredential 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 GetLogmeCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *LogmeCredentialState, opts ...pulumi.ResourceOption) (*LogmeCredential, error) { + var resource LogmeCredential + err := ctx.ReadResource("stackit:index/logmeCredential:LogmeCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering LogmeCredential resources. +type logmeCredentialState struct { + // The credential's ID. + CredentialId *string `pulumi:"credentialId"` + Host *string `pulumi:"host"` + // ID of the LogMe instance. + InstanceId *string `pulumi:"instanceId"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Uri *string `pulumi:"uri"` + Username *string `pulumi:"username"` +} + +type LogmeCredentialState struct { + // The credential's ID. + CredentialId pulumi.StringPtrInput + Host pulumi.StringPtrInput + // ID of the LogMe instance. + InstanceId pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Uri pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (LogmeCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*logmeCredentialState)(nil)).Elem() +} + +type logmeCredentialArgs struct { + // ID of the LogMe instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a LogmeCredential resource. +type LogmeCredentialArgs struct { + // ID of the LogMe instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (LogmeCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*logmeCredentialArgs)(nil)).Elem() +} + +type LogmeCredentialInput interface { + pulumi.Input + + ToLogmeCredentialOutput() LogmeCredentialOutput + ToLogmeCredentialOutputWithContext(ctx context.Context) LogmeCredentialOutput +} + +func (*LogmeCredential) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeCredential)(nil)).Elem() +} + +func (i *LogmeCredential) ToLogmeCredentialOutput() LogmeCredentialOutput { + return i.ToLogmeCredentialOutputWithContext(context.Background()) +} + +func (i *LogmeCredential) ToLogmeCredentialOutputWithContext(ctx context.Context) LogmeCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeCredentialOutput) +} + +// LogmeCredentialArrayInput is an input type that accepts LogmeCredentialArray and LogmeCredentialArrayOutput values. +// You can construct a concrete instance of `LogmeCredentialArrayInput` via: +// +// LogmeCredentialArray{ LogmeCredentialArgs{...} } +type LogmeCredentialArrayInput interface { + pulumi.Input + + ToLogmeCredentialArrayOutput() LogmeCredentialArrayOutput + ToLogmeCredentialArrayOutputWithContext(context.Context) LogmeCredentialArrayOutput +} + +type LogmeCredentialArray []LogmeCredentialInput + +func (LogmeCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LogmeCredential)(nil)).Elem() +} + +func (i LogmeCredentialArray) ToLogmeCredentialArrayOutput() LogmeCredentialArrayOutput { + return i.ToLogmeCredentialArrayOutputWithContext(context.Background()) +} + +func (i LogmeCredentialArray) ToLogmeCredentialArrayOutputWithContext(ctx context.Context) LogmeCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeCredentialArrayOutput) +} + +// LogmeCredentialMapInput is an input type that accepts LogmeCredentialMap and LogmeCredentialMapOutput values. +// You can construct a concrete instance of `LogmeCredentialMapInput` via: +// +// LogmeCredentialMap{ "key": LogmeCredentialArgs{...} } +type LogmeCredentialMapInput interface { + pulumi.Input + + ToLogmeCredentialMapOutput() LogmeCredentialMapOutput + ToLogmeCredentialMapOutputWithContext(context.Context) LogmeCredentialMapOutput +} + +type LogmeCredentialMap map[string]LogmeCredentialInput + +func (LogmeCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LogmeCredential)(nil)).Elem() +} + +func (i LogmeCredentialMap) ToLogmeCredentialMapOutput() LogmeCredentialMapOutput { + return i.ToLogmeCredentialMapOutputWithContext(context.Background()) +} + +func (i LogmeCredentialMap) ToLogmeCredentialMapOutputWithContext(ctx context.Context) LogmeCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeCredentialMapOutput) +} + +type LogmeCredentialOutput struct{ *pulumi.OutputState } + +func (LogmeCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeCredential)(nil)).Elem() +} + +func (o LogmeCredentialOutput) ToLogmeCredentialOutput() LogmeCredentialOutput { + return o +} + +func (o LogmeCredentialOutput) ToLogmeCredentialOutputWithContext(ctx context.Context) LogmeCredentialOutput { + return o +} + +// The credential's ID. +func (o LogmeCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o LogmeCredentialOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +// ID of the LogMe instance. +func (o LogmeCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o LogmeCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o LogmeCredentialOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o LogmeCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o LogmeCredentialOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +func (o LogmeCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type LogmeCredentialArrayOutput struct{ *pulumi.OutputState } + +func (LogmeCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LogmeCredential)(nil)).Elem() +} + +func (o LogmeCredentialArrayOutput) ToLogmeCredentialArrayOutput() LogmeCredentialArrayOutput { + return o +} + +func (o LogmeCredentialArrayOutput) ToLogmeCredentialArrayOutputWithContext(ctx context.Context) LogmeCredentialArrayOutput { + return o +} + +func (o LogmeCredentialArrayOutput) Index(i pulumi.IntInput) LogmeCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LogmeCredential { + return vs[0].([]*LogmeCredential)[vs[1].(int)] + }).(LogmeCredentialOutput) +} + +type LogmeCredentialMapOutput struct{ *pulumi.OutputState } + +func (LogmeCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LogmeCredential)(nil)).Elem() +} + +func (o LogmeCredentialMapOutput) ToLogmeCredentialMapOutput() LogmeCredentialMapOutput { + return o +} + +func (o LogmeCredentialMapOutput) ToLogmeCredentialMapOutputWithContext(ctx context.Context) LogmeCredentialMapOutput { + return o +} + +func (o LogmeCredentialMapOutput) MapIndex(k pulumi.StringInput) LogmeCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LogmeCredential { + return vs[0].(map[string]*LogmeCredential)[vs[1].(string)] + }).(LogmeCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*LogmeCredentialInput)(nil)).Elem(), &LogmeCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeCredentialArrayInput)(nil)).Elem(), LogmeCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeCredentialMapInput)(nil)).Elem(), LogmeCredentialMap{}) + pulumi.RegisterOutputType(LogmeCredentialOutput{}) + pulumi.RegisterOutputType(LogmeCredentialArrayOutput{}) + pulumi.RegisterOutputType(LogmeCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/logmeInstance.go b/sdk/go/stackit/logmeInstance.go new file mode 100644 index 0000000..3f27765 --- /dev/null +++ b/sdk/go/stackit/logmeInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// LogMe instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type LogmeInstance struct { + pulumi.CustomResourceState + + CfGuid pulumi.StringOutput `pulumi:"cfGuid"` + CfOrganizationGuid pulumi.StringOutput `pulumi:"cfOrganizationGuid"` + CfSpaceGuid pulumi.StringOutput `pulumi:"cfSpaceGuid"` + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + ImageUrl pulumi.StringOutput `pulumi:"imageUrl"` + // ID of the LogMe instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Parameters LogmeInstanceParametersOutput `pulumi:"parameters"` + // The selected plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // The selected plan name. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The service version. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewLogmeInstance registers a new resource with the given unique name, arguments, and options. +func NewLogmeInstance(ctx *pulumi.Context, + name string, args *LogmeInstanceArgs, opts ...pulumi.ResourceOption) (*LogmeInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource LogmeInstance + err := ctx.RegisterResource("stackit:index/logmeInstance:LogmeInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetLogmeInstance gets an existing LogmeInstance 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 GetLogmeInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *LogmeInstanceState, opts ...pulumi.ResourceOption) (*LogmeInstance, error) { + var resource LogmeInstance + err := ctx.ReadResource("stackit:index/logmeInstance:LogmeInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering LogmeInstance resources. +type logmeInstanceState struct { + CfGuid *string `pulumi:"cfGuid"` + CfOrganizationGuid *string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid *string `pulumi:"cfSpaceGuid"` + DashboardUrl *string `pulumi:"dashboardUrl"` + ImageUrl *string `pulumi:"imageUrl"` + // ID of the LogMe instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Parameters *LogmeInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId *string `pulumi:"planId"` + // The selected plan name. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The service version. + Version *string `pulumi:"version"` +} + +type LogmeInstanceState struct { + CfGuid pulumi.StringPtrInput + CfOrganizationGuid pulumi.StringPtrInput + CfSpaceGuid pulumi.StringPtrInput + DashboardUrl pulumi.StringPtrInput + ImageUrl pulumi.StringPtrInput + // ID of the LogMe instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Parameters LogmeInstanceParametersPtrInput + // The selected plan ID. + PlanId pulumi.StringPtrInput + // The selected plan name. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The service version. + Version pulumi.StringPtrInput +} + +func (LogmeInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*logmeInstanceState)(nil)).Elem() +} + +type logmeInstanceArgs struct { + // Instance name. + Name *string `pulumi:"name"` + Parameters *LogmeInstanceParameters `pulumi:"parameters"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a LogmeInstance resource. +type LogmeInstanceArgs struct { + // Instance name. + Name pulumi.StringPtrInput + Parameters LogmeInstanceParametersPtrInput + // The selected plan name. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The service version. + Version pulumi.StringInput +} + +func (LogmeInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*logmeInstanceArgs)(nil)).Elem() +} + +type LogmeInstanceInput interface { + pulumi.Input + + ToLogmeInstanceOutput() LogmeInstanceOutput + ToLogmeInstanceOutputWithContext(ctx context.Context) LogmeInstanceOutput +} + +func (*LogmeInstance) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeInstance)(nil)).Elem() +} + +func (i *LogmeInstance) ToLogmeInstanceOutput() LogmeInstanceOutput { + return i.ToLogmeInstanceOutputWithContext(context.Background()) +} + +func (i *LogmeInstance) ToLogmeInstanceOutputWithContext(ctx context.Context) LogmeInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceOutput) +} + +// LogmeInstanceArrayInput is an input type that accepts LogmeInstanceArray and LogmeInstanceArrayOutput values. +// You can construct a concrete instance of `LogmeInstanceArrayInput` via: +// +// LogmeInstanceArray{ LogmeInstanceArgs{...} } +type LogmeInstanceArrayInput interface { + pulumi.Input + + ToLogmeInstanceArrayOutput() LogmeInstanceArrayOutput + ToLogmeInstanceArrayOutputWithContext(context.Context) LogmeInstanceArrayOutput +} + +type LogmeInstanceArray []LogmeInstanceInput + +func (LogmeInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LogmeInstance)(nil)).Elem() +} + +func (i LogmeInstanceArray) ToLogmeInstanceArrayOutput() LogmeInstanceArrayOutput { + return i.ToLogmeInstanceArrayOutputWithContext(context.Background()) +} + +func (i LogmeInstanceArray) ToLogmeInstanceArrayOutputWithContext(ctx context.Context) LogmeInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceArrayOutput) +} + +// LogmeInstanceMapInput is an input type that accepts LogmeInstanceMap and LogmeInstanceMapOutput values. +// You can construct a concrete instance of `LogmeInstanceMapInput` via: +// +// LogmeInstanceMap{ "key": LogmeInstanceArgs{...} } +type LogmeInstanceMapInput interface { + pulumi.Input + + ToLogmeInstanceMapOutput() LogmeInstanceMapOutput + ToLogmeInstanceMapOutputWithContext(context.Context) LogmeInstanceMapOutput +} + +type LogmeInstanceMap map[string]LogmeInstanceInput + +func (LogmeInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LogmeInstance)(nil)).Elem() +} + +func (i LogmeInstanceMap) ToLogmeInstanceMapOutput() LogmeInstanceMapOutput { + return i.ToLogmeInstanceMapOutputWithContext(context.Background()) +} + +func (i LogmeInstanceMap) ToLogmeInstanceMapOutputWithContext(ctx context.Context) LogmeInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceMapOutput) +} + +type LogmeInstanceOutput struct{ *pulumi.OutputState } + +func (LogmeInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeInstance)(nil)).Elem() +} + +func (o LogmeInstanceOutput) ToLogmeInstanceOutput() LogmeInstanceOutput { + return o +} + +func (o LogmeInstanceOutput) ToLogmeInstanceOutputWithContext(ctx context.Context) LogmeInstanceOutput { + return o +} + +func (o LogmeInstanceOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o LogmeInstanceOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o LogmeInstanceOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o LogmeInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o LogmeInstanceOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the LogMe instance. +func (o LogmeInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o LogmeInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o LogmeInstanceOutput) Parameters() LogmeInstanceParametersOutput { + return o.ApplyT(func(v *LogmeInstance) LogmeInstanceParametersOutput { return v.Parameters }).(LogmeInstanceParametersOutput) +} + +// The selected plan ID. +func (o LogmeInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o LogmeInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o LogmeInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o LogmeInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *LogmeInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type LogmeInstanceArrayOutput struct{ *pulumi.OutputState } + +func (LogmeInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*LogmeInstance)(nil)).Elem() +} + +func (o LogmeInstanceArrayOutput) ToLogmeInstanceArrayOutput() LogmeInstanceArrayOutput { + return o +} + +func (o LogmeInstanceArrayOutput) ToLogmeInstanceArrayOutputWithContext(ctx context.Context) LogmeInstanceArrayOutput { + return o +} + +func (o LogmeInstanceArrayOutput) Index(i pulumi.IntInput) LogmeInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LogmeInstance { + return vs[0].([]*LogmeInstance)[vs[1].(int)] + }).(LogmeInstanceOutput) +} + +type LogmeInstanceMapOutput struct{ *pulumi.OutputState } + +func (LogmeInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*LogmeInstance)(nil)).Elem() +} + +func (o LogmeInstanceMapOutput) ToLogmeInstanceMapOutput() LogmeInstanceMapOutput { + return o +} + +func (o LogmeInstanceMapOutput) ToLogmeInstanceMapOutputWithContext(ctx context.Context) LogmeInstanceMapOutput { + return o +} + +func (o LogmeInstanceMapOutput) MapIndex(k pulumi.StringInput) LogmeInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LogmeInstance { + return vs[0].(map[string]*LogmeInstance)[vs[1].(string)] + }).(LogmeInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*LogmeInstanceInput)(nil)).Elem(), &LogmeInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeInstanceArrayInput)(nil)).Elem(), LogmeInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeInstanceMapInput)(nil)).Elem(), LogmeInstanceMap{}) + pulumi.RegisterOutputType(LogmeInstanceOutput{}) + pulumi.RegisterOutputType(LogmeInstanceArrayOutput{}) + pulumi.RegisterOutputType(LogmeInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/mariadbCredential.go b/sdk/go/stackit/mariadbCredential.go new file mode 100644 index 0000000..dd39a24 --- /dev/null +++ b/sdk/go/stackit/mariadbCredential.go @@ -0,0 +1,304 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MariaDB credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type MariadbCredential struct { + pulumi.CustomResourceState + + // The credential's ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + Host pulumi.StringOutput `pulumi:"host"` + Hosts pulumi.StringArrayOutput `pulumi:"hosts"` + // ID of the MariaDB instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Name pulumi.StringOutput `pulumi:"name"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Uri pulumi.StringOutput `pulumi:"uri"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewMariadbCredential registers a new resource with the given unique name, arguments, and options. +func NewMariadbCredential(ctx *pulumi.Context, + name string, args *MariadbCredentialArgs, opts ...pulumi.ResourceOption) (*MariadbCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource MariadbCredential + err := ctx.RegisterResource("stackit:index/mariadbCredential:MariadbCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetMariadbCredential gets an existing MariadbCredential 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 GetMariadbCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *MariadbCredentialState, opts ...pulumi.ResourceOption) (*MariadbCredential, error) { + var resource MariadbCredential + err := ctx.ReadResource("stackit:index/mariadbCredential:MariadbCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering MariadbCredential resources. +type mariadbCredentialState struct { + // The credential's ID. + CredentialId *string `pulumi:"credentialId"` + Host *string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + // ID of the MariaDB instance. + InstanceId *string `pulumi:"instanceId"` + Name *string `pulumi:"name"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Uri *string `pulumi:"uri"` + Username *string `pulumi:"username"` +} + +type MariadbCredentialState struct { + // The credential's ID. + CredentialId pulumi.StringPtrInput + Host pulumi.StringPtrInput + Hosts pulumi.StringArrayInput + // ID of the MariaDB instance. + InstanceId pulumi.StringPtrInput + Name pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Uri pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (MariadbCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*mariadbCredentialState)(nil)).Elem() +} + +type mariadbCredentialArgs struct { + // ID of the MariaDB instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a MariadbCredential resource. +type MariadbCredentialArgs struct { + // ID of the MariaDB instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (MariadbCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*mariadbCredentialArgs)(nil)).Elem() +} + +type MariadbCredentialInput interface { + pulumi.Input + + ToMariadbCredentialOutput() MariadbCredentialOutput + ToMariadbCredentialOutputWithContext(ctx context.Context) MariadbCredentialOutput +} + +func (*MariadbCredential) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbCredential)(nil)).Elem() +} + +func (i *MariadbCredential) ToMariadbCredentialOutput() MariadbCredentialOutput { + return i.ToMariadbCredentialOutputWithContext(context.Background()) +} + +func (i *MariadbCredential) ToMariadbCredentialOutputWithContext(ctx context.Context) MariadbCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbCredentialOutput) +} + +// MariadbCredentialArrayInput is an input type that accepts MariadbCredentialArray and MariadbCredentialArrayOutput values. +// You can construct a concrete instance of `MariadbCredentialArrayInput` via: +// +// MariadbCredentialArray{ MariadbCredentialArgs{...} } +type MariadbCredentialArrayInput interface { + pulumi.Input + + ToMariadbCredentialArrayOutput() MariadbCredentialArrayOutput + ToMariadbCredentialArrayOutputWithContext(context.Context) MariadbCredentialArrayOutput +} + +type MariadbCredentialArray []MariadbCredentialInput + +func (MariadbCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MariadbCredential)(nil)).Elem() +} + +func (i MariadbCredentialArray) ToMariadbCredentialArrayOutput() MariadbCredentialArrayOutput { + return i.ToMariadbCredentialArrayOutputWithContext(context.Background()) +} + +func (i MariadbCredentialArray) ToMariadbCredentialArrayOutputWithContext(ctx context.Context) MariadbCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbCredentialArrayOutput) +} + +// MariadbCredentialMapInput is an input type that accepts MariadbCredentialMap and MariadbCredentialMapOutput values. +// You can construct a concrete instance of `MariadbCredentialMapInput` via: +// +// MariadbCredentialMap{ "key": MariadbCredentialArgs{...} } +type MariadbCredentialMapInput interface { + pulumi.Input + + ToMariadbCredentialMapOutput() MariadbCredentialMapOutput + ToMariadbCredentialMapOutputWithContext(context.Context) MariadbCredentialMapOutput +} + +type MariadbCredentialMap map[string]MariadbCredentialInput + +func (MariadbCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MariadbCredential)(nil)).Elem() +} + +func (i MariadbCredentialMap) ToMariadbCredentialMapOutput() MariadbCredentialMapOutput { + return i.ToMariadbCredentialMapOutputWithContext(context.Background()) +} + +func (i MariadbCredentialMap) ToMariadbCredentialMapOutputWithContext(ctx context.Context) MariadbCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbCredentialMapOutput) +} + +type MariadbCredentialOutput struct{ *pulumi.OutputState } + +func (MariadbCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbCredential)(nil)).Elem() +} + +func (o MariadbCredentialOutput) ToMariadbCredentialOutput() MariadbCredentialOutput { + return o +} + +func (o MariadbCredentialOutput) ToMariadbCredentialOutputWithContext(ctx context.Context) MariadbCredentialOutput { + return o +} + +// The credential's ID. +func (o MariadbCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringArrayOutput { return v.Hosts }).(pulumi.StringArrayOutput) +} + +// ID of the MariaDB instance. +func (o MariadbCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o MariadbCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +func (o MariadbCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type MariadbCredentialArrayOutput struct{ *pulumi.OutputState } + +func (MariadbCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MariadbCredential)(nil)).Elem() +} + +func (o MariadbCredentialArrayOutput) ToMariadbCredentialArrayOutput() MariadbCredentialArrayOutput { + return o +} + +func (o MariadbCredentialArrayOutput) ToMariadbCredentialArrayOutputWithContext(ctx context.Context) MariadbCredentialArrayOutput { + return o +} + +func (o MariadbCredentialArrayOutput) Index(i pulumi.IntInput) MariadbCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MariadbCredential { + return vs[0].([]*MariadbCredential)[vs[1].(int)] + }).(MariadbCredentialOutput) +} + +type MariadbCredentialMapOutput struct{ *pulumi.OutputState } + +func (MariadbCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MariadbCredential)(nil)).Elem() +} + +func (o MariadbCredentialMapOutput) ToMariadbCredentialMapOutput() MariadbCredentialMapOutput { + return o +} + +func (o MariadbCredentialMapOutput) ToMariadbCredentialMapOutputWithContext(ctx context.Context) MariadbCredentialMapOutput { + return o +} + +func (o MariadbCredentialMapOutput) MapIndex(k pulumi.StringInput) MariadbCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MariadbCredential { + return vs[0].(map[string]*MariadbCredential)[vs[1].(string)] + }).(MariadbCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*MariadbCredentialInput)(nil)).Elem(), &MariadbCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbCredentialArrayInput)(nil)).Elem(), MariadbCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbCredentialMapInput)(nil)).Elem(), MariadbCredentialMap{}) + pulumi.RegisterOutputType(MariadbCredentialOutput{}) + pulumi.RegisterOutputType(MariadbCredentialArrayOutput{}) + pulumi.RegisterOutputType(MariadbCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/mariadbInstance.go b/sdk/go/stackit/mariadbInstance.go new file mode 100644 index 0000000..6298f4f --- /dev/null +++ b/sdk/go/stackit/mariadbInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MariaDB instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type MariadbInstance struct { + pulumi.CustomResourceState + + CfGuid pulumi.StringOutput `pulumi:"cfGuid"` + CfOrganizationGuid pulumi.StringOutput `pulumi:"cfOrganizationGuid"` + CfSpaceGuid pulumi.StringOutput `pulumi:"cfSpaceGuid"` + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + ImageUrl pulumi.StringOutput `pulumi:"imageUrl"` + // ID of the MariaDB instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Parameters MariadbInstanceParametersOutput `pulumi:"parameters"` + // The selected plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // The selected plan name. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The service version. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewMariadbInstance registers a new resource with the given unique name, arguments, and options. +func NewMariadbInstance(ctx *pulumi.Context, + name string, args *MariadbInstanceArgs, opts ...pulumi.ResourceOption) (*MariadbInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource MariadbInstance + err := ctx.RegisterResource("stackit:index/mariadbInstance:MariadbInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetMariadbInstance gets an existing MariadbInstance 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 GetMariadbInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *MariadbInstanceState, opts ...pulumi.ResourceOption) (*MariadbInstance, error) { + var resource MariadbInstance + err := ctx.ReadResource("stackit:index/mariadbInstance:MariadbInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering MariadbInstance resources. +type mariadbInstanceState struct { + CfGuid *string `pulumi:"cfGuid"` + CfOrganizationGuid *string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid *string `pulumi:"cfSpaceGuid"` + DashboardUrl *string `pulumi:"dashboardUrl"` + ImageUrl *string `pulumi:"imageUrl"` + // ID of the MariaDB instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Parameters *MariadbInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId *string `pulumi:"planId"` + // The selected plan name. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The service version. + Version *string `pulumi:"version"` +} + +type MariadbInstanceState struct { + CfGuid pulumi.StringPtrInput + CfOrganizationGuid pulumi.StringPtrInput + CfSpaceGuid pulumi.StringPtrInput + DashboardUrl pulumi.StringPtrInput + ImageUrl pulumi.StringPtrInput + // ID of the MariaDB instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Parameters MariadbInstanceParametersPtrInput + // The selected plan ID. + PlanId pulumi.StringPtrInput + // The selected plan name. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The service version. + Version pulumi.StringPtrInput +} + +func (MariadbInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*mariadbInstanceState)(nil)).Elem() +} + +type mariadbInstanceArgs struct { + // Instance name. + Name *string `pulumi:"name"` + Parameters *MariadbInstanceParameters `pulumi:"parameters"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a MariadbInstance resource. +type MariadbInstanceArgs struct { + // Instance name. + Name pulumi.StringPtrInput + Parameters MariadbInstanceParametersPtrInput + // The selected plan name. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The service version. + Version pulumi.StringInput +} + +func (MariadbInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*mariadbInstanceArgs)(nil)).Elem() +} + +type MariadbInstanceInput interface { + pulumi.Input + + ToMariadbInstanceOutput() MariadbInstanceOutput + ToMariadbInstanceOutputWithContext(ctx context.Context) MariadbInstanceOutput +} + +func (*MariadbInstance) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbInstance)(nil)).Elem() +} + +func (i *MariadbInstance) ToMariadbInstanceOutput() MariadbInstanceOutput { + return i.ToMariadbInstanceOutputWithContext(context.Background()) +} + +func (i *MariadbInstance) ToMariadbInstanceOutputWithContext(ctx context.Context) MariadbInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceOutput) +} + +// MariadbInstanceArrayInput is an input type that accepts MariadbInstanceArray and MariadbInstanceArrayOutput values. +// You can construct a concrete instance of `MariadbInstanceArrayInput` via: +// +// MariadbInstanceArray{ MariadbInstanceArgs{...} } +type MariadbInstanceArrayInput interface { + pulumi.Input + + ToMariadbInstanceArrayOutput() MariadbInstanceArrayOutput + ToMariadbInstanceArrayOutputWithContext(context.Context) MariadbInstanceArrayOutput +} + +type MariadbInstanceArray []MariadbInstanceInput + +func (MariadbInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MariadbInstance)(nil)).Elem() +} + +func (i MariadbInstanceArray) ToMariadbInstanceArrayOutput() MariadbInstanceArrayOutput { + return i.ToMariadbInstanceArrayOutputWithContext(context.Background()) +} + +func (i MariadbInstanceArray) ToMariadbInstanceArrayOutputWithContext(ctx context.Context) MariadbInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceArrayOutput) +} + +// MariadbInstanceMapInput is an input type that accepts MariadbInstanceMap and MariadbInstanceMapOutput values. +// You can construct a concrete instance of `MariadbInstanceMapInput` via: +// +// MariadbInstanceMap{ "key": MariadbInstanceArgs{...} } +type MariadbInstanceMapInput interface { + pulumi.Input + + ToMariadbInstanceMapOutput() MariadbInstanceMapOutput + ToMariadbInstanceMapOutputWithContext(context.Context) MariadbInstanceMapOutput +} + +type MariadbInstanceMap map[string]MariadbInstanceInput + +func (MariadbInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MariadbInstance)(nil)).Elem() +} + +func (i MariadbInstanceMap) ToMariadbInstanceMapOutput() MariadbInstanceMapOutput { + return i.ToMariadbInstanceMapOutputWithContext(context.Background()) +} + +func (i MariadbInstanceMap) ToMariadbInstanceMapOutputWithContext(ctx context.Context) MariadbInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceMapOutput) +} + +type MariadbInstanceOutput struct{ *pulumi.OutputState } + +func (MariadbInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbInstance)(nil)).Elem() +} + +func (o MariadbInstanceOutput) ToMariadbInstanceOutput() MariadbInstanceOutput { + return o +} + +func (o MariadbInstanceOutput) ToMariadbInstanceOutputWithContext(ctx context.Context) MariadbInstanceOutput { + return o +} + +func (o MariadbInstanceOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o MariadbInstanceOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o MariadbInstanceOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o MariadbInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o MariadbInstanceOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the MariaDB instance. +func (o MariadbInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o MariadbInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o MariadbInstanceOutput) Parameters() MariadbInstanceParametersOutput { + return o.ApplyT(func(v *MariadbInstance) MariadbInstanceParametersOutput { return v.Parameters }).(MariadbInstanceParametersOutput) +} + +// The selected plan ID. +func (o MariadbInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o MariadbInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o MariadbInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o MariadbInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *MariadbInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type MariadbInstanceArrayOutput struct{ *pulumi.OutputState } + +func (MariadbInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MariadbInstance)(nil)).Elem() +} + +func (o MariadbInstanceArrayOutput) ToMariadbInstanceArrayOutput() MariadbInstanceArrayOutput { + return o +} + +func (o MariadbInstanceArrayOutput) ToMariadbInstanceArrayOutputWithContext(ctx context.Context) MariadbInstanceArrayOutput { + return o +} + +func (o MariadbInstanceArrayOutput) Index(i pulumi.IntInput) MariadbInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MariadbInstance { + return vs[0].([]*MariadbInstance)[vs[1].(int)] + }).(MariadbInstanceOutput) +} + +type MariadbInstanceMapOutput struct{ *pulumi.OutputState } + +func (MariadbInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MariadbInstance)(nil)).Elem() +} + +func (o MariadbInstanceMapOutput) ToMariadbInstanceMapOutput() MariadbInstanceMapOutput { + return o +} + +func (o MariadbInstanceMapOutput) ToMariadbInstanceMapOutputWithContext(ctx context.Context) MariadbInstanceMapOutput { + return o +} + +func (o MariadbInstanceMapOutput) MapIndex(k pulumi.StringInput) MariadbInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MariadbInstance { + return vs[0].(map[string]*MariadbInstance)[vs[1].(string)] + }).(MariadbInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*MariadbInstanceInput)(nil)).Elem(), &MariadbInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbInstanceArrayInput)(nil)).Elem(), MariadbInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbInstanceMapInput)(nil)).Elem(), MariadbInstanceMap{}) + pulumi.RegisterOutputType(MariadbInstanceOutput{}) + pulumi.RegisterOutputType(MariadbInstanceArrayOutput{}) + pulumi.RegisterOutputType(MariadbInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/modelservingToken.go b/sdk/go/stackit/modelservingToken.go new file mode 100644 index 0000000..aae291b --- /dev/null +++ b/sdk/go/stackit/modelservingToken.go @@ -0,0 +1,346 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// AI Model Serving Auth Token Resource schema. +// +// ## Example Usage +// +// ### Automatically rotate AI model serving token +type ModelservingToken struct { + pulumi.CustomResourceState + + // The description of the AI model serving auth token. + Description pulumi.StringPtrOutput `pulumi:"description"` + // Name of the AI model serving auth token. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the AI model serving auth token is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Region to which the AI model serving auth token is associated. If not defined, the provider region is used + Region pulumi.StringOutput `pulumi:"region"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapOutput `pulumi:"rotateWhenChanged"` + // State of the AI model serving auth token. + State pulumi.StringOutput `pulumi:"state"` + // Content of the AI model serving auth token. + Token pulumi.StringOutput `pulumi:"token"` + // The AI model serving auth token ID. + TokenId pulumi.StringOutput `pulumi:"tokenId"` + // The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + TtlDuration pulumi.StringPtrOutput `pulumi:"ttlDuration"` + // The time until the AI model serving auth token is valid. + ValidUntil pulumi.StringOutput `pulumi:"validUntil"` +} + +// NewModelservingToken registers a new resource with the given unique name, arguments, and options. +func NewModelservingToken(ctx *pulumi.Context, + name string, args *ModelservingTokenArgs, opts ...pulumi.ResourceOption) (*ModelservingToken, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "token", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ModelservingToken + err := ctx.RegisterResource("stackit:index/modelservingToken:ModelservingToken", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetModelservingToken gets an existing ModelservingToken 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 GetModelservingToken(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ModelservingTokenState, opts ...pulumi.ResourceOption) (*ModelservingToken, error) { + var resource ModelservingToken + err := ctx.ReadResource("stackit:index/modelservingToken:ModelservingToken", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ModelservingToken resources. +type modelservingTokenState struct { + // The description of the AI model serving auth token. + Description *string `pulumi:"description"` + // Name of the AI model serving auth token. + Name *string `pulumi:"name"` + // STACKIT project ID to which the AI model serving auth token is associated. + ProjectId *string `pulumi:"projectId"` + // Region to which the AI model serving auth token is associated. If not defined, the provider region is used + Region *string `pulumi:"region"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // State of the AI model serving auth token. + State *string `pulumi:"state"` + // Content of the AI model serving auth token. + Token *string `pulumi:"token"` + // The AI model serving auth token ID. + TokenId *string `pulumi:"tokenId"` + // The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + TtlDuration *string `pulumi:"ttlDuration"` + // The time until the AI model serving auth token is valid. + ValidUntil *string `pulumi:"validUntil"` +} + +type ModelservingTokenState struct { + // The description of the AI model serving auth token. + Description pulumi.StringPtrInput + // Name of the AI model serving auth token. + Name pulumi.StringPtrInput + // STACKIT project ID to which the AI model serving auth token is associated. + ProjectId pulumi.StringPtrInput + // Region to which the AI model serving auth token is associated. If not defined, the provider region is used + Region pulumi.StringPtrInput + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapInput + // State of the AI model serving auth token. + State pulumi.StringPtrInput + // Content of the AI model serving auth token. + Token pulumi.StringPtrInput + // The AI model serving auth token ID. + TokenId pulumi.StringPtrInput + // The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + TtlDuration pulumi.StringPtrInput + // The time until the AI model serving auth token is valid. + ValidUntil pulumi.StringPtrInput +} + +func (ModelservingTokenState) ElementType() reflect.Type { + return reflect.TypeOf((*modelservingTokenState)(nil)).Elem() +} + +type modelservingTokenArgs struct { + // The description of the AI model serving auth token. + Description *string `pulumi:"description"` + // Name of the AI model serving auth token. + Name *string `pulumi:"name"` + // STACKIT project ID to which the AI model serving auth token is associated. + ProjectId string `pulumi:"projectId"` + // Region to which the AI model serving auth token is associated. If not defined, the provider region is used + Region *string `pulumi:"region"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + TtlDuration *string `pulumi:"ttlDuration"` +} + +// The set of arguments for constructing a ModelservingToken resource. +type ModelservingTokenArgs struct { + // The description of the AI model serving auth token. + Description pulumi.StringPtrInput + // Name of the AI model serving auth token. + Name pulumi.StringPtrInput + // STACKIT project ID to which the AI model serving auth token is associated. + ProjectId pulumi.StringInput + // Region to which the AI model serving auth token is associated. If not defined, the provider region is used + Region pulumi.StringPtrInput + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapInput + // The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + TtlDuration pulumi.StringPtrInput +} + +func (ModelservingTokenArgs) ElementType() reflect.Type { + return reflect.TypeOf((*modelservingTokenArgs)(nil)).Elem() +} + +type ModelservingTokenInput interface { + pulumi.Input + + ToModelservingTokenOutput() ModelservingTokenOutput + ToModelservingTokenOutputWithContext(ctx context.Context) ModelservingTokenOutput +} + +func (*ModelservingToken) ElementType() reflect.Type { + return reflect.TypeOf((**ModelservingToken)(nil)).Elem() +} + +func (i *ModelservingToken) ToModelservingTokenOutput() ModelservingTokenOutput { + return i.ToModelservingTokenOutputWithContext(context.Background()) +} + +func (i *ModelservingToken) ToModelservingTokenOutputWithContext(ctx context.Context) ModelservingTokenOutput { + return pulumi.ToOutputWithContext(ctx, i).(ModelservingTokenOutput) +} + +// ModelservingTokenArrayInput is an input type that accepts ModelservingTokenArray and ModelservingTokenArrayOutput values. +// You can construct a concrete instance of `ModelservingTokenArrayInput` via: +// +// ModelservingTokenArray{ ModelservingTokenArgs{...} } +type ModelservingTokenArrayInput interface { + pulumi.Input + + ToModelservingTokenArrayOutput() ModelservingTokenArrayOutput + ToModelservingTokenArrayOutputWithContext(context.Context) ModelservingTokenArrayOutput +} + +type ModelservingTokenArray []ModelservingTokenInput + +func (ModelservingTokenArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ModelservingToken)(nil)).Elem() +} + +func (i ModelservingTokenArray) ToModelservingTokenArrayOutput() ModelservingTokenArrayOutput { + return i.ToModelservingTokenArrayOutputWithContext(context.Background()) +} + +func (i ModelservingTokenArray) ToModelservingTokenArrayOutputWithContext(ctx context.Context) ModelservingTokenArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ModelservingTokenArrayOutput) +} + +// ModelservingTokenMapInput is an input type that accepts ModelservingTokenMap and ModelservingTokenMapOutput values. +// You can construct a concrete instance of `ModelservingTokenMapInput` via: +// +// ModelservingTokenMap{ "key": ModelservingTokenArgs{...} } +type ModelservingTokenMapInput interface { + pulumi.Input + + ToModelservingTokenMapOutput() ModelservingTokenMapOutput + ToModelservingTokenMapOutputWithContext(context.Context) ModelservingTokenMapOutput +} + +type ModelservingTokenMap map[string]ModelservingTokenInput + +func (ModelservingTokenMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ModelservingToken)(nil)).Elem() +} + +func (i ModelservingTokenMap) ToModelservingTokenMapOutput() ModelservingTokenMapOutput { + return i.ToModelservingTokenMapOutputWithContext(context.Background()) +} + +func (i ModelservingTokenMap) ToModelservingTokenMapOutputWithContext(ctx context.Context) ModelservingTokenMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ModelservingTokenMapOutput) +} + +type ModelservingTokenOutput struct{ *pulumi.OutputState } + +func (ModelservingTokenOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ModelservingToken)(nil)).Elem() +} + +func (o ModelservingTokenOutput) ToModelservingTokenOutput() ModelservingTokenOutput { + return o +} + +func (o ModelservingTokenOutput) ToModelservingTokenOutputWithContext(ctx context.Context) ModelservingTokenOutput { + return o +} + +// The description of the AI model serving auth token. +func (o ModelservingTokenOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// Name of the AI model serving auth token. +func (o ModelservingTokenOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the AI model serving auth token is associated. +func (o ModelservingTokenOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Region to which the AI model serving auth token is associated. If not defined, the provider region is used +func (o ModelservingTokenOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. +func (o ModelservingTokenOutput) RotateWhenChanged() pulumi.StringMapOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringMapOutput { return v.RotateWhenChanged }).(pulumi.StringMapOutput) +} + +// State of the AI model serving auth token. +func (o ModelservingTokenOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.State }).(pulumi.StringOutput) +} + +// Content of the AI model serving auth token. +func (o ModelservingTokenOutput) Token() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.Token }).(pulumi.StringOutput) +} + +// The AI model serving auth token ID. +func (o ModelservingTokenOutput) TokenId() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.TokenId }).(pulumi.StringOutput) +} + +// The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s +func (o ModelservingTokenOutput) TtlDuration() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringPtrOutput { return v.TtlDuration }).(pulumi.StringPtrOutput) +} + +// The time until the AI model serving auth token is valid. +func (o ModelservingTokenOutput) ValidUntil() pulumi.StringOutput { + return o.ApplyT(func(v *ModelservingToken) pulumi.StringOutput { return v.ValidUntil }).(pulumi.StringOutput) +} + +type ModelservingTokenArrayOutput struct{ *pulumi.OutputState } + +func (ModelservingTokenArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ModelservingToken)(nil)).Elem() +} + +func (o ModelservingTokenArrayOutput) ToModelservingTokenArrayOutput() ModelservingTokenArrayOutput { + return o +} + +func (o ModelservingTokenArrayOutput) ToModelservingTokenArrayOutputWithContext(ctx context.Context) ModelservingTokenArrayOutput { + return o +} + +func (o ModelservingTokenArrayOutput) Index(i pulumi.IntInput) ModelservingTokenOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ModelservingToken { + return vs[0].([]*ModelservingToken)[vs[1].(int)] + }).(ModelservingTokenOutput) +} + +type ModelservingTokenMapOutput struct{ *pulumi.OutputState } + +func (ModelservingTokenMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ModelservingToken)(nil)).Elem() +} + +func (o ModelservingTokenMapOutput) ToModelservingTokenMapOutput() ModelservingTokenMapOutput { + return o +} + +func (o ModelservingTokenMapOutput) ToModelservingTokenMapOutputWithContext(ctx context.Context) ModelservingTokenMapOutput { + return o +} + +func (o ModelservingTokenMapOutput) MapIndex(k pulumi.StringInput) ModelservingTokenOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ModelservingToken { + return vs[0].(map[string]*ModelservingToken)[vs[1].(string)] + }).(ModelservingTokenOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ModelservingTokenInput)(nil)).Elem(), &ModelservingToken{}) + pulumi.RegisterInputType(reflect.TypeOf((*ModelservingTokenArrayInput)(nil)).Elem(), ModelservingTokenArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ModelservingTokenMapInput)(nil)).Elem(), ModelservingTokenMap{}) + pulumi.RegisterOutputType(ModelservingTokenOutput{}) + pulumi.RegisterOutputType(ModelservingTokenArrayOutput{}) + pulumi.RegisterOutputType(ModelservingTokenMapOutput{}) +} diff --git a/sdk/go/stackit/mongodbflexInstance.go b/sdk/go/stackit/mongodbflexInstance.go new file mode 100644 index 0000000..7efd33f --- /dev/null +++ b/sdk/go/stackit/mongodbflexInstance.go @@ -0,0 +1,343 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type MongodbflexInstance struct { + pulumi.CustomResourceState + + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls pulumi.StringArrayOutput `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule pulumi.StringOutput `pulumi:"backupSchedule"` + Flavor MongodbflexInstanceFlavorOutput `pulumi:"flavor"` + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Options MongodbflexInstanceOptionsOutput `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Replicas pulumi.IntOutput `pulumi:"replicas"` + Storage MongodbflexInstanceStorageOutput `pulumi:"storage"` + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewMongodbflexInstance registers a new resource with the given unique name, arguments, and options. +func NewMongodbflexInstance(ctx *pulumi.Context, + name string, args *MongodbflexInstanceArgs, opts ...pulumi.ResourceOption) (*MongodbflexInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Acls == nil { + return nil, errors.New("invalid value for required argument 'Acls'") + } + if args.BackupSchedule == nil { + return nil, errors.New("invalid value for required argument 'BackupSchedule'") + } + if args.Flavor == nil { + return nil, errors.New("invalid value for required argument 'Flavor'") + } + if args.Options == nil { + return nil, errors.New("invalid value for required argument 'Options'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Replicas == nil { + return nil, errors.New("invalid value for required argument 'Replicas'") + } + if args.Storage == nil { + return nil, errors.New("invalid value for required argument 'Storage'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource MongodbflexInstance + err := ctx.RegisterResource("stackit:index/mongodbflexInstance:MongodbflexInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetMongodbflexInstance gets an existing MongodbflexInstance 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 GetMongodbflexInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *MongodbflexInstanceState, opts ...pulumi.ResourceOption) (*MongodbflexInstance, error) { + var resource MongodbflexInstance + err := ctx.ReadResource("stackit:index/mongodbflexInstance:MongodbflexInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering MongodbflexInstance resources. +type mongodbflexInstanceState struct { + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule *string `pulumi:"backupSchedule"` + Flavor *MongodbflexInstanceFlavor `pulumi:"flavor"` + // ID of the MongoDB Flex instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Options *MongodbflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Replicas *int `pulumi:"replicas"` + Storage *MongodbflexInstanceStorage `pulumi:"storage"` + Version *string `pulumi:"version"` +} + +type MongodbflexInstanceState struct { + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls pulumi.StringArrayInput + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule pulumi.StringPtrInput + Flavor MongodbflexInstanceFlavorPtrInput + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Options MongodbflexInstanceOptionsPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Replicas pulumi.IntPtrInput + Storage MongodbflexInstanceStoragePtrInput + Version pulumi.StringPtrInput +} + +func (MongodbflexInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*mongodbflexInstanceState)(nil)).Elem() +} + +type mongodbflexInstanceArgs struct { + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule string `pulumi:"backupSchedule"` + Flavor MongodbflexInstanceFlavor `pulumi:"flavor"` + // Instance name. + Name *string `pulumi:"name"` + Options MongodbflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Replicas int `pulumi:"replicas"` + Storage MongodbflexInstanceStorage `pulumi:"storage"` + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a MongodbflexInstance resource. +type MongodbflexInstanceArgs struct { + // The Access Control List (ACL) for the MongoDB Flex instance. + Acls pulumi.StringArrayInput + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + BackupSchedule pulumi.StringInput + Flavor MongodbflexInstanceFlavorInput + // Instance name. + Name pulumi.StringPtrInput + Options MongodbflexInstanceOptionsInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + Replicas pulumi.IntInput + Storage MongodbflexInstanceStorageInput + Version pulumi.StringInput +} + +func (MongodbflexInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*mongodbflexInstanceArgs)(nil)).Elem() +} + +type MongodbflexInstanceInput interface { + pulumi.Input + + ToMongodbflexInstanceOutput() MongodbflexInstanceOutput + ToMongodbflexInstanceOutputWithContext(ctx context.Context) MongodbflexInstanceOutput +} + +func (*MongodbflexInstance) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstance)(nil)).Elem() +} + +func (i *MongodbflexInstance) ToMongodbflexInstanceOutput() MongodbflexInstanceOutput { + return i.ToMongodbflexInstanceOutputWithContext(context.Background()) +} + +func (i *MongodbflexInstance) ToMongodbflexInstanceOutputWithContext(ctx context.Context) MongodbflexInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceOutput) +} + +// MongodbflexInstanceArrayInput is an input type that accepts MongodbflexInstanceArray and MongodbflexInstanceArrayOutput values. +// You can construct a concrete instance of `MongodbflexInstanceArrayInput` via: +// +// MongodbflexInstanceArray{ MongodbflexInstanceArgs{...} } +type MongodbflexInstanceArrayInput interface { + pulumi.Input + + ToMongodbflexInstanceArrayOutput() MongodbflexInstanceArrayOutput + ToMongodbflexInstanceArrayOutputWithContext(context.Context) MongodbflexInstanceArrayOutput +} + +type MongodbflexInstanceArray []MongodbflexInstanceInput + +func (MongodbflexInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MongodbflexInstance)(nil)).Elem() +} + +func (i MongodbflexInstanceArray) ToMongodbflexInstanceArrayOutput() MongodbflexInstanceArrayOutput { + return i.ToMongodbflexInstanceArrayOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceArray) ToMongodbflexInstanceArrayOutputWithContext(ctx context.Context) MongodbflexInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceArrayOutput) +} + +// MongodbflexInstanceMapInput is an input type that accepts MongodbflexInstanceMap and MongodbflexInstanceMapOutput values. +// You can construct a concrete instance of `MongodbflexInstanceMapInput` via: +// +// MongodbflexInstanceMap{ "key": MongodbflexInstanceArgs{...} } +type MongodbflexInstanceMapInput interface { + pulumi.Input + + ToMongodbflexInstanceMapOutput() MongodbflexInstanceMapOutput + ToMongodbflexInstanceMapOutputWithContext(context.Context) MongodbflexInstanceMapOutput +} + +type MongodbflexInstanceMap map[string]MongodbflexInstanceInput + +func (MongodbflexInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MongodbflexInstance)(nil)).Elem() +} + +func (i MongodbflexInstanceMap) ToMongodbflexInstanceMapOutput() MongodbflexInstanceMapOutput { + return i.ToMongodbflexInstanceMapOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceMap) ToMongodbflexInstanceMapOutputWithContext(ctx context.Context) MongodbflexInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceMapOutput) +} + +type MongodbflexInstanceOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstance)(nil)).Elem() +} + +func (o MongodbflexInstanceOutput) ToMongodbflexInstanceOutput() MongodbflexInstanceOutput { + return o +} + +func (o MongodbflexInstanceOutput) ToMongodbflexInstanceOutputWithContext(ctx context.Context) MongodbflexInstanceOutput { + return o +} + +// The Access Control List (ACL) for the MongoDB Flex instance. +func (o MongodbflexInstanceOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringArrayOutput { return v.Acls }).(pulumi.StringArrayOutput) +} + +// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). +func (o MongodbflexInstanceOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringOutput { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o MongodbflexInstanceOutput) Flavor() MongodbflexInstanceFlavorOutput { + return o.ApplyT(func(v *MongodbflexInstance) MongodbflexInstanceFlavorOutput { return v.Flavor }).(MongodbflexInstanceFlavorOutput) +} + +// ID of the MongoDB Flex instance. +func (o MongodbflexInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o MongodbflexInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o MongodbflexInstanceOutput) Options() MongodbflexInstanceOptionsOutput { + return o.ApplyT(func(v *MongodbflexInstance) MongodbflexInstanceOptionsOutput { return v.Options }).(MongodbflexInstanceOptionsOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o MongodbflexInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o MongodbflexInstanceOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.IntOutput { return v.Replicas }).(pulumi.IntOutput) +} + +func (o MongodbflexInstanceOutput) Storage() MongodbflexInstanceStorageOutput { + return o.ApplyT(func(v *MongodbflexInstance) MongodbflexInstanceStorageOutput { return v.Storage }).(MongodbflexInstanceStorageOutput) +} + +func (o MongodbflexInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type MongodbflexInstanceArrayOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MongodbflexInstance)(nil)).Elem() +} + +func (o MongodbflexInstanceArrayOutput) ToMongodbflexInstanceArrayOutput() MongodbflexInstanceArrayOutput { + return o +} + +func (o MongodbflexInstanceArrayOutput) ToMongodbflexInstanceArrayOutputWithContext(ctx context.Context) MongodbflexInstanceArrayOutput { + return o +} + +func (o MongodbflexInstanceArrayOutput) Index(i pulumi.IntInput) MongodbflexInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MongodbflexInstance { + return vs[0].([]*MongodbflexInstance)[vs[1].(int)] + }).(MongodbflexInstanceOutput) +} + +type MongodbflexInstanceMapOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MongodbflexInstance)(nil)).Elem() +} + +func (o MongodbflexInstanceMapOutput) ToMongodbflexInstanceMapOutput() MongodbflexInstanceMapOutput { + return o +} + +func (o MongodbflexInstanceMapOutput) ToMongodbflexInstanceMapOutputWithContext(ctx context.Context) MongodbflexInstanceMapOutput { + return o +} + +func (o MongodbflexInstanceMapOutput) MapIndex(k pulumi.StringInput) MongodbflexInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MongodbflexInstance { + return vs[0].(map[string]*MongodbflexInstance)[vs[1].(string)] + }).(MongodbflexInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceInput)(nil)).Elem(), &MongodbflexInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceArrayInput)(nil)).Elem(), MongodbflexInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceMapInput)(nil)).Elem(), MongodbflexInstanceMap{}) + pulumi.RegisterOutputType(MongodbflexInstanceOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceArrayOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/mongodbflexUser.go b/sdk/go/stackit/mongodbflexUser.go new file mode 100644 index 0000000..879abf1 --- /dev/null +++ b/sdk/go/stackit/mongodbflexUser.go @@ -0,0 +1,322 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type MongodbflexUser struct { + pulumi.CustomResourceState + + Database pulumi.StringOutput `pulumi:"database"` + Host pulumi.StringOutput `pulumi:"host"` + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + Roles pulumi.StringArrayOutput `pulumi:"roles"` + Uri pulumi.StringOutput `pulumi:"uri"` + // User ID. + UserId pulumi.StringOutput `pulumi:"userId"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewMongodbflexUser registers a new resource with the given unique name, arguments, and options. +func NewMongodbflexUser(ctx *pulumi.Context, + name string, args *MongodbflexUserArgs, opts ...pulumi.ResourceOption) (*MongodbflexUser, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Database == nil { + return nil, errors.New("invalid value for required argument 'Database'") + } + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Roles == nil { + return nil, errors.New("invalid value for required argument 'Roles'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource MongodbflexUser + err := ctx.RegisterResource("stackit:index/mongodbflexUser:MongodbflexUser", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetMongodbflexUser gets an existing MongodbflexUser 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 GetMongodbflexUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *MongodbflexUserState, opts ...pulumi.ResourceOption) (*MongodbflexUser, error) { + var resource MongodbflexUser + err := ctx.ReadResource("stackit:index/mongodbflexUser:MongodbflexUser", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering MongodbflexUser resources. +type mongodbflexUserState struct { + Database *string `pulumi:"database"` + Host *string `pulumi:"host"` + // ID of the MongoDB Flex instance. + InstanceId *string `pulumi:"instanceId"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + Roles []string `pulumi:"roles"` + Uri *string `pulumi:"uri"` + // User ID. + UserId *string `pulumi:"userId"` + Username *string `pulumi:"username"` +} + +type MongodbflexUserState struct { + Database pulumi.StringPtrInput + Host pulumi.StringPtrInput + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + Roles pulumi.StringArrayInput + Uri pulumi.StringPtrInput + // User ID. + UserId pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (MongodbflexUserState) ElementType() reflect.Type { + return reflect.TypeOf((*mongodbflexUserState)(nil)).Elem() +} + +type mongodbflexUserArgs struct { + Database string `pulumi:"database"` + // ID of the MongoDB Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + Roles []string `pulumi:"roles"` + Username *string `pulumi:"username"` +} + +// The set of arguments for constructing a MongodbflexUser resource. +type MongodbflexUserArgs struct { + Database pulumi.StringInput + // ID of the MongoDB Flex instance. + InstanceId pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + Roles pulumi.StringArrayInput + Username pulumi.StringPtrInput +} + +func (MongodbflexUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*mongodbflexUserArgs)(nil)).Elem() +} + +type MongodbflexUserInput interface { + pulumi.Input + + ToMongodbflexUserOutput() MongodbflexUserOutput + ToMongodbflexUserOutputWithContext(ctx context.Context) MongodbflexUserOutput +} + +func (*MongodbflexUser) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexUser)(nil)).Elem() +} + +func (i *MongodbflexUser) ToMongodbflexUserOutput() MongodbflexUserOutput { + return i.ToMongodbflexUserOutputWithContext(context.Background()) +} + +func (i *MongodbflexUser) ToMongodbflexUserOutputWithContext(ctx context.Context) MongodbflexUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexUserOutput) +} + +// MongodbflexUserArrayInput is an input type that accepts MongodbflexUserArray and MongodbflexUserArrayOutput values. +// You can construct a concrete instance of `MongodbflexUserArrayInput` via: +// +// MongodbflexUserArray{ MongodbflexUserArgs{...} } +type MongodbflexUserArrayInput interface { + pulumi.Input + + ToMongodbflexUserArrayOutput() MongodbflexUserArrayOutput + ToMongodbflexUserArrayOutputWithContext(context.Context) MongodbflexUserArrayOutput +} + +type MongodbflexUserArray []MongodbflexUserInput + +func (MongodbflexUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MongodbflexUser)(nil)).Elem() +} + +func (i MongodbflexUserArray) ToMongodbflexUserArrayOutput() MongodbflexUserArrayOutput { + return i.ToMongodbflexUserArrayOutputWithContext(context.Background()) +} + +func (i MongodbflexUserArray) ToMongodbflexUserArrayOutputWithContext(ctx context.Context) MongodbflexUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexUserArrayOutput) +} + +// MongodbflexUserMapInput is an input type that accepts MongodbflexUserMap and MongodbflexUserMapOutput values. +// You can construct a concrete instance of `MongodbflexUserMapInput` via: +// +// MongodbflexUserMap{ "key": MongodbflexUserArgs{...} } +type MongodbflexUserMapInput interface { + pulumi.Input + + ToMongodbflexUserMapOutput() MongodbflexUserMapOutput + ToMongodbflexUserMapOutputWithContext(context.Context) MongodbflexUserMapOutput +} + +type MongodbflexUserMap map[string]MongodbflexUserInput + +func (MongodbflexUserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MongodbflexUser)(nil)).Elem() +} + +func (i MongodbflexUserMap) ToMongodbflexUserMapOutput() MongodbflexUserMapOutput { + return i.ToMongodbflexUserMapOutputWithContext(context.Background()) +} + +func (i MongodbflexUserMap) ToMongodbflexUserMapOutputWithContext(ctx context.Context) MongodbflexUserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexUserMapOutput) +} + +type MongodbflexUserOutput struct{ *pulumi.OutputState } + +func (MongodbflexUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexUser)(nil)).Elem() +} + +func (o MongodbflexUserOutput) ToMongodbflexUserOutput() MongodbflexUserOutput { + return o +} + +func (o MongodbflexUserOutput) ToMongodbflexUserOutputWithContext(ctx context.Context) MongodbflexUserOutput { + return o +} + +func (o MongodbflexUserOutput) Database() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.Database }).(pulumi.StringOutput) +} + +func (o MongodbflexUserOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +// ID of the MongoDB Flex instance. +func (o MongodbflexUserOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o MongodbflexUserOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o MongodbflexUserOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o MongodbflexUserOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] +func (o MongodbflexUserOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringArrayOutput { return v.Roles }).(pulumi.StringArrayOutput) +} + +func (o MongodbflexUserOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +// User ID. +func (o MongodbflexUserOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.UserId }).(pulumi.StringOutput) +} + +func (o MongodbflexUserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *MongodbflexUser) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type MongodbflexUserArrayOutput struct{ *pulumi.OutputState } + +func (MongodbflexUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*MongodbflexUser)(nil)).Elem() +} + +func (o MongodbflexUserArrayOutput) ToMongodbflexUserArrayOutput() MongodbflexUserArrayOutput { + return o +} + +func (o MongodbflexUserArrayOutput) ToMongodbflexUserArrayOutputWithContext(ctx context.Context) MongodbflexUserArrayOutput { + return o +} + +func (o MongodbflexUserArrayOutput) Index(i pulumi.IntInput) MongodbflexUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *MongodbflexUser { + return vs[0].([]*MongodbflexUser)[vs[1].(int)] + }).(MongodbflexUserOutput) +} + +type MongodbflexUserMapOutput struct{ *pulumi.OutputState } + +func (MongodbflexUserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*MongodbflexUser)(nil)).Elem() +} + +func (o MongodbflexUserMapOutput) ToMongodbflexUserMapOutput() MongodbflexUserMapOutput { + return o +} + +func (o MongodbflexUserMapOutput) ToMongodbflexUserMapOutputWithContext(ctx context.Context) MongodbflexUserMapOutput { + return o +} + +func (o MongodbflexUserMapOutput) MapIndex(k pulumi.StringInput) MongodbflexUserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *MongodbflexUser { + return vs[0].(map[string]*MongodbflexUser)[vs[1].(string)] + }).(MongodbflexUserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexUserInput)(nil)).Elem(), &MongodbflexUser{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexUserArrayInput)(nil)).Elem(), MongodbflexUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexUserMapInput)(nil)).Elem(), MongodbflexUserMap{}) + pulumi.RegisterOutputType(MongodbflexUserOutput{}) + pulumi.RegisterOutputType(MongodbflexUserArrayOutput{}) + pulumi.RegisterOutputType(MongodbflexUserMapOutput{}) +} diff --git a/sdk/go/stackit/network.go b/sdk/go/stackit/network.go new file mode 100644 index 0000000..6a366b1 --- /dev/null +++ b/sdk/go/stackit/network.go @@ -0,0 +1,506 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type Network struct { + pulumi.CustomResourceState + + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway pulumi.StringOutput `pulumi:"ipv4Gateway"` + // The IPv4 nameservers of the network. + Ipv4Nameservers pulumi.StringArrayOutput `pulumi:"ipv4Nameservers"` + // The IPv4 prefix of the network (CIDR). + Ipv4Prefix pulumi.StringOutput `pulumi:"ipv4Prefix"` + // The IPv4 prefix length of the network. + Ipv4PrefixLength pulumi.IntOutput `pulumi:"ipv4PrefixLength"` + // The IPv4 prefixes of the network. + Ipv4Prefixes pulumi.StringArrayOutput `pulumi:"ipv4Prefixes"` + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway pulumi.StringOutput `pulumi:"ipv6Gateway"` + // The IPv6 nameservers of the network. + Ipv6Nameservers pulumi.StringArrayOutput `pulumi:"ipv6Nameservers"` + // The IPv6 prefix of the network (CIDR). + Ipv6Prefix pulumi.StringPtrOutput `pulumi:"ipv6Prefix"` + // The IPv6 prefix length of the network. + Ipv6PrefixLength pulumi.IntPtrOutput `pulumi:"ipv6PrefixLength"` + // The IPv6 prefixes of the network. + Ipv6Prefixes pulumi.StringArrayOutput `pulumi:"ipv6Prefixes"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The name of the network. + Name pulumi.StringOutput `pulumi:"name"` + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers pulumi.StringArrayOutput `pulumi:"nameservers"` + // The network ID. + NetworkId pulumi.StringOutput `pulumi:"networkId"` + // If set to `true`, the network doesn't have a gateway. + NoIpv4Gateway pulumi.BoolPtrOutput `pulumi:"noIpv4Gateway"` + // If set to `true`, the network doesn't have a gateway. + NoIpv6Gateway pulumi.BoolPtrOutput `pulumi:"noIpv6Gateway"` + // The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + // + // Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + Prefixes pulumi.StringArrayOutput `pulumi:"prefixes"` + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The public IP of the network. + PublicIp pulumi.StringOutput `pulumi:"publicIp"` + // If set to `true`, the network is routed and therefore accessible from other networks. + Routed pulumi.BoolOutput `pulumi:"routed"` +} + +// NewNetwork registers a new resource with the given unique name, arguments, and options. +func NewNetwork(ctx *pulumi.Context, + name string, args *NetworkArgs, opts ...pulumi.ResourceOption) (*Network, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Network + err := ctx.RegisterResource("stackit:index/network:Network", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNetwork gets an existing Network 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 GetNetwork(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NetworkState, opts ...pulumi.ResourceOption) (*Network, error) { + var resource Network + err := ctx.ReadResource("stackit:index/network:Network", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Network resources. +type networkState struct { + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway *string `pulumi:"ipv4Gateway"` + // The IPv4 nameservers of the network. + Ipv4Nameservers []string `pulumi:"ipv4Nameservers"` + // The IPv4 prefix of the network (CIDR). + Ipv4Prefix *string `pulumi:"ipv4Prefix"` + // The IPv4 prefix length of the network. + Ipv4PrefixLength *int `pulumi:"ipv4PrefixLength"` + // The IPv4 prefixes of the network. + Ipv4Prefixes []string `pulumi:"ipv4Prefixes"` + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway *string `pulumi:"ipv6Gateway"` + // The IPv6 nameservers of the network. + Ipv6Nameservers []string `pulumi:"ipv6Nameservers"` + // The IPv6 prefix of the network (CIDR). + Ipv6Prefix *string `pulumi:"ipv6Prefix"` + // The IPv6 prefix length of the network. + Ipv6PrefixLength *int `pulumi:"ipv6PrefixLength"` + // The IPv6 prefixes of the network. + Ipv6Prefixes []string `pulumi:"ipv6Prefixes"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the network. + Name *string `pulumi:"name"` + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers []string `pulumi:"nameservers"` + // The network ID. + NetworkId *string `pulumi:"networkId"` + // If set to `true`, the network doesn't have a gateway. + NoIpv4Gateway *bool `pulumi:"noIpv4Gateway"` + // If set to `true`, the network doesn't have a gateway. + NoIpv6Gateway *bool `pulumi:"noIpv6Gateway"` + // The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + // + // Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + Prefixes []string `pulumi:"prefixes"` + // STACKIT project ID to which the network is associated. + ProjectId *string `pulumi:"projectId"` + // The public IP of the network. + PublicIp *string `pulumi:"publicIp"` + // If set to `true`, the network is routed and therefore accessible from other networks. + Routed *bool `pulumi:"routed"` +} + +type NetworkState struct { + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway pulumi.StringPtrInput + // The IPv4 nameservers of the network. + Ipv4Nameservers pulumi.StringArrayInput + // The IPv4 prefix of the network (CIDR). + Ipv4Prefix pulumi.StringPtrInput + // The IPv4 prefix length of the network. + Ipv4PrefixLength pulumi.IntPtrInput + // The IPv4 prefixes of the network. + Ipv4Prefixes pulumi.StringArrayInput + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway pulumi.StringPtrInput + // The IPv6 nameservers of the network. + Ipv6Nameservers pulumi.StringArrayInput + // The IPv6 prefix of the network (CIDR). + Ipv6Prefix pulumi.StringPtrInput + // The IPv6 prefix length of the network. + Ipv6PrefixLength pulumi.IntPtrInput + // The IPv6 prefixes of the network. + Ipv6Prefixes pulumi.StringArrayInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the network. + Name pulumi.StringPtrInput + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers pulumi.StringArrayInput + // The network ID. + NetworkId pulumi.StringPtrInput + // If set to `true`, the network doesn't have a gateway. + NoIpv4Gateway pulumi.BoolPtrInput + // If set to `true`, the network doesn't have a gateway. + NoIpv6Gateway pulumi.BoolPtrInput + // The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + // + // Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + Prefixes pulumi.StringArrayInput + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringPtrInput + // The public IP of the network. + PublicIp pulumi.StringPtrInput + // If set to `true`, the network is routed and therefore accessible from other networks. + Routed pulumi.BoolPtrInput +} + +func (NetworkState) ElementType() reflect.Type { + return reflect.TypeOf((*networkState)(nil)).Elem() +} + +type networkArgs struct { + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway *string `pulumi:"ipv4Gateway"` + // The IPv4 nameservers of the network. + Ipv4Nameservers []string `pulumi:"ipv4Nameservers"` + // The IPv4 prefix of the network (CIDR). + Ipv4Prefix *string `pulumi:"ipv4Prefix"` + // The IPv4 prefix length of the network. + Ipv4PrefixLength *int `pulumi:"ipv4PrefixLength"` + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway *string `pulumi:"ipv6Gateway"` + // The IPv6 nameservers of the network. + Ipv6Nameservers []string `pulumi:"ipv6Nameservers"` + // The IPv6 prefix of the network (CIDR). + Ipv6Prefix *string `pulumi:"ipv6Prefix"` + // The IPv6 prefix length of the network. + Ipv6PrefixLength *int `pulumi:"ipv6PrefixLength"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the network. + Name *string `pulumi:"name"` + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers []string `pulumi:"nameservers"` + // If set to `true`, the network doesn't have a gateway. + NoIpv4Gateway *bool `pulumi:"noIpv4Gateway"` + // If set to `true`, the network doesn't have a gateway. + NoIpv6Gateway *bool `pulumi:"noIpv6Gateway"` + // STACKIT project ID to which the network is associated. + ProjectId string `pulumi:"projectId"` + // If set to `true`, the network is routed and therefore accessible from other networks. + Routed *bool `pulumi:"routed"` +} + +// The set of arguments for constructing a Network resource. +type NetworkArgs struct { + // The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv4Gateway pulumi.StringPtrInput + // The IPv4 nameservers of the network. + Ipv4Nameservers pulumi.StringArrayInput + // The IPv4 prefix of the network (CIDR). + Ipv4Prefix pulumi.StringPtrInput + // The IPv4 prefix length of the network. + Ipv4PrefixLength pulumi.IntPtrInput + // The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + Ipv6Gateway pulumi.StringPtrInput + // The IPv6 nameservers of the network. + Ipv6Nameservers pulumi.StringArrayInput + // The IPv6 prefix of the network (CIDR). + Ipv6Prefix pulumi.StringPtrInput + // The IPv6 prefix length of the network. + Ipv6PrefixLength pulumi.IntPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the network. + Name pulumi.StringPtrInput + // The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + // + // Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. + Nameservers pulumi.StringArrayInput + // If set to `true`, the network doesn't have a gateway. + NoIpv4Gateway pulumi.BoolPtrInput + // If set to `true`, the network doesn't have a gateway. + NoIpv6Gateway pulumi.BoolPtrInput + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringInput + // If set to `true`, the network is routed and therefore accessible from other networks. + Routed pulumi.BoolPtrInput +} + +func (NetworkArgs) ElementType() reflect.Type { + return reflect.TypeOf((*networkArgs)(nil)).Elem() +} + +type NetworkInput interface { + pulumi.Input + + ToNetworkOutput() NetworkOutput + ToNetworkOutputWithContext(ctx context.Context) NetworkOutput +} + +func (*Network) ElementType() reflect.Type { + return reflect.TypeOf((**Network)(nil)).Elem() +} + +func (i *Network) ToNetworkOutput() NetworkOutput { + return i.ToNetworkOutputWithContext(context.Background()) +} + +func (i *Network) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkOutput) +} + +// NetworkArrayInput is an input type that accepts NetworkArray and NetworkArrayOutput values. +// You can construct a concrete instance of `NetworkArrayInput` via: +// +// NetworkArray{ NetworkArgs{...} } +type NetworkArrayInput interface { + pulumi.Input + + ToNetworkArrayOutput() NetworkArrayOutput + ToNetworkArrayOutputWithContext(context.Context) NetworkArrayOutput +} + +type NetworkArray []NetworkInput + +func (NetworkArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Network)(nil)).Elem() +} + +func (i NetworkArray) ToNetworkArrayOutput() NetworkArrayOutput { + return i.ToNetworkArrayOutputWithContext(context.Background()) +} + +func (i NetworkArray) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkArrayOutput) +} + +// NetworkMapInput is an input type that accepts NetworkMap and NetworkMapOutput values. +// You can construct a concrete instance of `NetworkMapInput` via: +// +// NetworkMap{ "key": NetworkArgs{...} } +type NetworkMapInput interface { + pulumi.Input + + ToNetworkMapOutput() NetworkMapOutput + ToNetworkMapOutputWithContext(context.Context) NetworkMapOutput +} + +type NetworkMap map[string]NetworkInput + +func (NetworkMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Network)(nil)).Elem() +} + +func (i NetworkMap) ToNetworkMapOutput() NetworkMapOutput { + return i.ToNetworkMapOutputWithContext(context.Background()) +} + +func (i NetworkMap) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkMapOutput) +} + +type NetworkOutput struct{ *pulumi.OutputState } + +func (NetworkOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Network)(nil)).Elem() +} + +func (o NetworkOutput) ToNetworkOutput() NetworkOutput { + return o +} + +func (o NetworkOutput) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput { + return o +} + +// The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. +func (o NetworkOutput) Ipv4Gateway() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Ipv4Gateway }).(pulumi.StringOutput) +} + +// The IPv4 nameservers of the network. +func (o NetworkOutput) Ipv4Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Ipv4Nameservers }).(pulumi.StringArrayOutput) +} + +// The IPv4 prefix of the network (CIDR). +func (o NetworkOutput) Ipv4Prefix() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Ipv4Prefix }).(pulumi.StringOutput) +} + +// The IPv4 prefix length of the network. +func (o NetworkOutput) Ipv4PrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v *Network) pulumi.IntOutput { return v.Ipv4PrefixLength }).(pulumi.IntOutput) +} + +// The IPv4 prefixes of the network. +func (o NetworkOutput) Ipv4Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Ipv4Prefixes }).(pulumi.StringArrayOutput) +} + +// The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. +func (o NetworkOutput) Ipv6Gateway() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Ipv6Gateway }).(pulumi.StringOutput) +} + +// The IPv6 nameservers of the network. +func (o NetworkOutput) Ipv6Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Ipv6Nameservers }).(pulumi.StringArrayOutput) +} + +// The IPv6 prefix of the network (CIDR). +func (o NetworkOutput) Ipv6Prefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Network) pulumi.StringPtrOutput { return v.Ipv6Prefix }).(pulumi.StringPtrOutput) +} + +// The IPv6 prefix length of the network. +func (o NetworkOutput) Ipv6PrefixLength() pulumi.IntPtrOutput { + return o.ApplyT(func(v *Network) pulumi.IntPtrOutput { return v.Ipv6PrefixLength }).(pulumi.IntPtrOutput) +} + +// The IPv6 prefixes of the network. +func (o NetworkOutput) Ipv6Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Ipv6Prefixes }).(pulumi.StringArrayOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o NetworkOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *Network) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the network. +func (o NetworkOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. +// +// Deprecated: Use `ipv4Nameservers` to configure the nameservers for IPv4. +func (o NetworkOutput) Nameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Nameservers }).(pulumi.StringArrayOutput) +} + +// The network ID. +func (o NetworkOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.NetworkId }).(pulumi.StringOutput) +} + +// If set to `true`, the network doesn't have a gateway. +func (o NetworkOutput) NoIpv4Gateway() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Network) pulumi.BoolPtrOutput { return v.NoIpv4Gateway }).(pulumi.BoolPtrOutput) +} + +// If set to `true`, the network doesn't have a gateway. +func (o NetworkOutput) NoIpv6Gateway() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Network) pulumi.BoolPtrOutput { return v.NoIpv6Gateway }).(pulumi.BoolPtrOutput) +} + +// The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. +// +// Deprecated: Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. +func (o NetworkOutput) Prefixes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Network) pulumi.StringArrayOutput { return v.Prefixes }).(pulumi.StringArrayOutput) +} + +// STACKIT project ID to which the network is associated. +func (o NetworkOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The public IP of the network. +func (o NetworkOutput) PublicIp() pulumi.StringOutput { + return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.PublicIp }).(pulumi.StringOutput) +} + +// If set to `true`, the network is routed and therefore accessible from other networks. +func (o NetworkOutput) Routed() pulumi.BoolOutput { + return o.ApplyT(func(v *Network) pulumi.BoolOutput { return v.Routed }).(pulumi.BoolOutput) +} + +type NetworkArrayOutput struct{ *pulumi.OutputState } + +func (NetworkArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Network)(nil)).Elem() +} + +func (o NetworkArrayOutput) ToNetworkArrayOutput() NetworkArrayOutput { + return o +} + +func (o NetworkArrayOutput) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput { + return o +} + +func (o NetworkArrayOutput) Index(i pulumi.IntInput) NetworkOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Network { + return vs[0].([]*Network)[vs[1].(int)] + }).(NetworkOutput) +} + +type NetworkMapOutput struct{ *pulumi.OutputState } + +func (NetworkMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Network)(nil)).Elem() +} + +func (o NetworkMapOutput) ToNetworkMapOutput() NetworkMapOutput { + return o +} + +func (o NetworkMapOutput) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput { + return o +} + +func (o NetworkMapOutput) MapIndex(k pulumi.StringInput) NetworkOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Network { + return vs[0].(map[string]*Network)[vs[1].(string)] + }).(NetworkOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NetworkInput)(nil)).Elem(), &Network{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkArrayInput)(nil)).Elem(), NetworkArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkMapInput)(nil)).Elem(), NetworkMap{}) + pulumi.RegisterOutputType(NetworkOutput{}) + pulumi.RegisterOutputType(NetworkArrayOutput{}) + pulumi.RegisterOutputType(NetworkMapOutput{}) +} diff --git a/sdk/go/stackit/networkArea.go b/sdk/go/stackit/networkArea.go new file mode 100644 index 0000000..ba4d412 --- /dev/null +++ b/sdk/go/stackit/networkArea.go @@ -0,0 +1,369 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network area resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type NetworkArea struct { + pulumi.CustomResourceState + + // List of DNS Servers/Nameservers. + DefaultNameservers pulumi.StringArrayOutput `pulumi:"defaultNameservers"` + // The default prefix length for networks in the network area. + DefaultPrefixLength pulumi.IntOutput `pulumi:"defaultPrefixLength"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The maximal prefix length for networks in the network area. + MaxPrefixLength pulumi.IntOutput `pulumi:"maxPrefixLength"` + // The minimal prefix length for networks in the network area. + MinPrefixLength pulumi.IntOutput `pulumi:"minPrefixLength"` + // The name of the network area. + Name pulumi.StringOutput `pulumi:"name"` + // The network area ID. + NetworkAreaId pulumi.StringOutput `pulumi:"networkAreaId"` + // List of Network ranges. + NetworkRanges NetworkAreaNetworkRangeArrayOutput `pulumi:"networkRanges"` + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringOutput `pulumi:"organizationId"` + // The amount of projects currently referencing this area. + ProjectCount pulumi.IntOutput `pulumi:"projectCount"` + // Classless Inter-Domain Routing (CIDR). + TransferNetwork pulumi.StringOutput `pulumi:"transferNetwork"` +} + +// NewNetworkArea registers a new resource with the given unique name, arguments, and options. +func NewNetworkArea(ctx *pulumi.Context, + name string, args *NetworkAreaArgs, opts ...pulumi.ResourceOption) (*NetworkArea, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NetworkRanges == nil { + return nil, errors.New("invalid value for required argument 'NetworkRanges'") + } + if args.OrganizationId == nil { + return nil, errors.New("invalid value for required argument 'OrganizationId'") + } + if args.TransferNetwork == nil { + return nil, errors.New("invalid value for required argument 'TransferNetwork'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource NetworkArea + err := ctx.RegisterResource("stackit:index/networkArea:NetworkArea", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNetworkArea gets an existing NetworkArea 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 GetNetworkArea(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NetworkAreaState, opts ...pulumi.ResourceOption) (*NetworkArea, error) { + var resource NetworkArea + err := ctx.ReadResource("stackit:index/networkArea:NetworkArea", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering NetworkArea resources. +type networkAreaState struct { + // List of DNS Servers/Nameservers. + DefaultNameservers []string `pulumi:"defaultNameservers"` + // The default prefix length for networks in the network area. + DefaultPrefixLength *int `pulumi:"defaultPrefixLength"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The maximal prefix length for networks in the network area. + MaxPrefixLength *int `pulumi:"maxPrefixLength"` + // The minimal prefix length for networks in the network area. + MinPrefixLength *int `pulumi:"minPrefixLength"` + // The name of the network area. + Name *string `pulumi:"name"` + // The network area ID. + NetworkAreaId *string `pulumi:"networkAreaId"` + // List of Network ranges. + NetworkRanges []NetworkAreaNetworkRange `pulumi:"networkRanges"` + // STACKIT organization ID to which the network area is associated. + OrganizationId *string `pulumi:"organizationId"` + // The amount of projects currently referencing this area. + ProjectCount *int `pulumi:"projectCount"` + // Classless Inter-Domain Routing (CIDR). + TransferNetwork *string `pulumi:"transferNetwork"` +} + +type NetworkAreaState struct { + // List of DNS Servers/Nameservers. + DefaultNameservers pulumi.StringArrayInput + // The default prefix length for networks in the network area. + DefaultPrefixLength pulumi.IntPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The maximal prefix length for networks in the network area. + MaxPrefixLength pulumi.IntPtrInput + // The minimal prefix length for networks in the network area. + MinPrefixLength pulumi.IntPtrInput + // The name of the network area. + Name pulumi.StringPtrInput + // The network area ID. + NetworkAreaId pulumi.StringPtrInput + // List of Network ranges. + NetworkRanges NetworkAreaNetworkRangeArrayInput + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringPtrInput + // The amount of projects currently referencing this area. + ProjectCount pulumi.IntPtrInput + // Classless Inter-Domain Routing (CIDR). + TransferNetwork pulumi.StringPtrInput +} + +func (NetworkAreaState) ElementType() reflect.Type { + return reflect.TypeOf((*networkAreaState)(nil)).Elem() +} + +type networkAreaArgs struct { + // List of DNS Servers/Nameservers. + DefaultNameservers []string `pulumi:"defaultNameservers"` + // The default prefix length for networks in the network area. + DefaultPrefixLength *int `pulumi:"defaultPrefixLength"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The maximal prefix length for networks in the network area. + MaxPrefixLength *int `pulumi:"maxPrefixLength"` + // The minimal prefix length for networks in the network area. + MinPrefixLength *int `pulumi:"minPrefixLength"` + // The name of the network area. + Name *string `pulumi:"name"` + // List of Network ranges. + NetworkRanges []NetworkAreaNetworkRange `pulumi:"networkRanges"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` + // Classless Inter-Domain Routing (CIDR). + TransferNetwork string `pulumi:"transferNetwork"` +} + +// The set of arguments for constructing a NetworkArea resource. +type NetworkAreaArgs struct { + // List of DNS Servers/Nameservers. + DefaultNameservers pulumi.StringArrayInput + // The default prefix length for networks in the network area. + DefaultPrefixLength pulumi.IntPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The maximal prefix length for networks in the network area. + MaxPrefixLength pulumi.IntPtrInput + // The minimal prefix length for networks in the network area. + MinPrefixLength pulumi.IntPtrInput + // The name of the network area. + Name pulumi.StringPtrInput + // List of Network ranges. + NetworkRanges NetworkAreaNetworkRangeArrayInput + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringInput + // Classless Inter-Domain Routing (CIDR). + TransferNetwork pulumi.StringInput +} + +func (NetworkAreaArgs) ElementType() reflect.Type { + return reflect.TypeOf((*networkAreaArgs)(nil)).Elem() +} + +type NetworkAreaInput interface { + pulumi.Input + + ToNetworkAreaOutput() NetworkAreaOutput + ToNetworkAreaOutputWithContext(ctx context.Context) NetworkAreaOutput +} + +func (*NetworkArea) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkArea)(nil)).Elem() +} + +func (i *NetworkArea) ToNetworkAreaOutput() NetworkAreaOutput { + return i.ToNetworkAreaOutputWithContext(context.Background()) +} + +func (i *NetworkArea) ToNetworkAreaOutputWithContext(ctx context.Context) NetworkAreaOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaOutput) +} + +// NetworkAreaArrayInput is an input type that accepts NetworkAreaArray and NetworkAreaArrayOutput values. +// You can construct a concrete instance of `NetworkAreaArrayInput` via: +// +// NetworkAreaArray{ NetworkAreaArgs{...} } +type NetworkAreaArrayInput interface { + pulumi.Input + + ToNetworkAreaArrayOutput() NetworkAreaArrayOutput + ToNetworkAreaArrayOutputWithContext(context.Context) NetworkAreaArrayOutput +} + +type NetworkAreaArray []NetworkAreaInput + +func (NetworkAreaArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkArea)(nil)).Elem() +} + +func (i NetworkAreaArray) ToNetworkAreaArrayOutput() NetworkAreaArrayOutput { + return i.ToNetworkAreaArrayOutputWithContext(context.Background()) +} + +func (i NetworkAreaArray) ToNetworkAreaArrayOutputWithContext(ctx context.Context) NetworkAreaArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaArrayOutput) +} + +// NetworkAreaMapInput is an input type that accepts NetworkAreaMap and NetworkAreaMapOutput values. +// You can construct a concrete instance of `NetworkAreaMapInput` via: +// +// NetworkAreaMap{ "key": NetworkAreaArgs{...} } +type NetworkAreaMapInput interface { + pulumi.Input + + ToNetworkAreaMapOutput() NetworkAreaMapOutput + ToNetworkAreaMapOutputWithContext(context.Context) NetworkAreaMapOutput +} + +type NetworkAreaMap map[string]NetworkAreaInput + +func (NetworkAreaMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkArea)(nil)).Elem() +} + +func (i NetworkAreaMap) ToNetworkAreaMapOutput() NetworkAreaMapOutput { + return i.ToNetworkAreaMapOutputWithContext(context.Background()) +} + +func (i NetworkAreaMap) ToNetworkAreaMapOutputWithContext(ctx context.Context) NetworkAreaMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaMapOutput) +} + +type NetworkAreaOutput struct{ *pulumi.OutputState } + +func (NetworkAreaOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkArea)(nil)).Elem() +} + +func (o NetworkAreaOutput) ToNetworkAreaOutput() NetworkAreaOutput { + return o +} + +func (o NetworkAreaOutput) ToNetworkAreaOutputWithContext(ctx context.Context) NetworkAreaOutput { + return o +} + +// List of DNS Servers/Nameservers. +func (o NetworkAreaOutput) DefaultNameservers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringArrayOutput { return v.DefaultNameservers }).(pulumi.StringArrayOutput) +} + +// The default prefix length for networks in the network area. +func (o NetworkAreaOutput) DefaultPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.IntOutput { return v.DefaultPrefixLength }).(pulumi.IntOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o NetworkAreaOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The maximal prefix length for networks in the network area. +func (o NetworkAreaOutput) MaxPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.IntOutput { return v.MaxPrefixLength }).(pulumi.IntOutput) +} + +// The minimal prefix length for networks in the network area. +func (o NetworkAreaOutput) MinPrefixLength() pulumi.IntOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.IntOutput { return v.MinPrefixLength }).(pulumi.IntOutput) +} + +// The name of the network area. +func (o NetworkAreaOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The network area ID. +func (o NetworkAreaOutput) NetworkAreaId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringOutput { return v.NetworkAreaId }).(pulumi.StringOutput) +} + +// List of Network ranges. +func (o NetworkAreaOutput) NetworkRanges() NetworkAreaNetworkRangeArrayOutput { + return o.ApplyT(func(v *NetworkArea) NetworkAreaNetworkRangeArrayOutput { return v.NetworkRanges }).(NetworkAreaNetworkRangeArrayOutput) +} + +// STACKIT organization ID to which the network area is associated. +func (o NetworkAreaOutput) OrganizationId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput) +} + +// The amount of projects currently referencing this area. +func (o NetworkAreaOutput) ProjectCount() pulumi.IntOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.IntOutput { return v.ProjectCount }).(pulumi.IntOutput) +} + +// Classless Inter-Domain Routing (CIDR). +func (o NetworkAreaOutput) TransferNetwork() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkArea) pulumi.StringOutput { return v.TransferNetwork }).(pulumi.StringOutput) +} + +type NetworkAreaArrayOutput struct{ *pulumi.OutputState } + +func (NetworkAreaArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkArea)(nil)).Elem() +} + +func (o NetworkAreaArrayOutput) ToNetworkAreaArrayOutput() NetworkAreaArrayOutput { + return o +} + +func (o NetworkAreaArrayOutput) ToNetworkAreaArrayOutputWithContext(ctx context.Context) NetworkAreaArrayOutput { + return o +} + +func (o NetworkAreaArrayOutput) Index(i pulumi.IntInput) NetworkAreaOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkArea { + return vs[0].([]*NetworkArea)[vs[1].(int)] + }).(NetworkAreaOutput) +} + +type NetworkAreaMapOutput struct{ *pulumi.OutputState } + +func (NetworkAreaMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkArea)(nil)).Elem() +} + +func (o NetworkAreaMapOutput) ToNetworkAreaMapOutput() NetworkAreaMapOutput { + return o +} + +func (o NetworkAreaMapOutput) ToNetworkAreaMapOutputWithContext(ctx context.Context) NetworkAreaMapOutput { + return o +} + +func (o NetworkAreaMapOutput) MapIndex(k pulumi.StringInput) NetworkAreaOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkArea { + return vs[0].(map[string]*NetworkArea)[vs[1].(string)] + }).(NetworkAreaOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaInput)(nil)).Elem(), &NetworkArea{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaArrayInput)(nil)).Elem(), NetworkAreaArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaMapInput)(nil)).Elem(), NetworkAreaMap{}) + pulumi.RegisterOutputType(NetworkAreaOutput{}) + pulumi.RegisterOutputType(NetworkAreaArrayOutput{}) + pulumi.RegisterOutputType(NetworkAreaMapOutput{}) +} diff --git a/sdk/go/stackit/networkAreaRoute.go b/sdk/go/stackit/networkAreaRoute.go new file mode 100644 index 0000000..39623e3 --- /dev/null +++ b/sdk/go/stackit/networkAreaRoute.go @@ -0,0 +1,301 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network area route resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type NetworkAreaRoute struct { + pulumi.CustomResourceState + + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The network area ID to which the network area route is associated. + NetworkAreaId pulumi.StringOutput `pulumi:"networkAreaId"` + // The network area route ID. + NetworkAreaRouteId pulumi.StringOutput `pulumi:"networkAreaRouteId"` + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop pulumi.StringOutput `pulumi:"nextHop"` + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringOutput `pulumi:"organizationId"` + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix pulumi.StringOutput `pulumi:"prefix"` +} + +// NewNetworkAreaRoute registers a new resource with the given unique name, arguments, and options. +func NewNetworkAreaRoute(ctx *pulumi.Context, + name string, args *NetworkAreaRouteArgs, opts ...pulumi.ResourceOption) (*NetworkAreaRoute, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NetworkAreaId == nil { + return nil, errors.New("invalid value for required argument 'NetworkAreaId'") + } + if args.NextHop == nil { + return nil, errors.New("invalid value for required argument 'NextHop'") + } + if args.OrganizationId == nil { + return nil, errors.New("invalid value for required argument 'OrganizationId'") + } + if args.Prefix == nil { + return nil, errors.New("invalid value for required argument 'Prefix'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource NetworkAreaRoute + err := ctx.RegisterResource("stackit:index/networkAreaRoute:NetworkAreaRoute", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNetworkAreaRoute gets an existing NetworkAreaRoute 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 GetNetworkAreaRoute(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NetworkAreaRouteState, opts ...pulumi.ResourceOption) (*NetworkAreaRoute, error) { + var resource NetworkAreaRoute + err := ctx.ReadResource("stackit:index/networkAreaRoute:NetworkAreaRoute", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering NetworkAreaRoute resources. +type networkAreaRouteState struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The network area ID to which the network area route is associated. + NetworkAreaId *string `pulumi:"networkAreaId"` + // The network area route ID. + NetworkAreaRouteId *string `pulumi:"networkAreaRouteId"` + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop *string `pulumi:"nextHop"` + // STACKIT organization ID to which the network area is associated. + OrganizationId *string `pulumi:"organizationId"` + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix *string `pulumi:"prefix"` +} + +type NetworkAreaRouteState struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The network area ID to which the network area route is associated. + NetworkAreaId pulumi.StringPtrInput + // The network area route ID. + NetworkAreaRouteId pulumi.StringPtrInput + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop pulumi.StringPtrInput + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringPtrInput + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix pulumi.StringPtrInput +} + +func (NetworkAreaRouteState) ElementType() reflect.Type { + return reflect.TypeOf((*networkAreaRouteState)(nil)).Elem() +} + +type networkAreaRouteArgs struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The network area ID to which the network area route is associated. + NetworkAreaId string `pulumi:"networkAreaId"` + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop string `pulumi:"nextHop"` + // STACKIT organization ID to which the network area is associated. + OrganizationId string `pulumi:"organizationId"` + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix string `pulumi:"prefix"` +} + +// The set of arguments for constructing a NetworkAreaRoute resource. +type NetworkAreaRouteArgs struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The network area ID to which the network area route is associated. + NetworkAreaId pulumi.StringInput + // The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + NextHop pulumi.StringInput + // STACKIT organization ID to which the network area is associated. + OrganizationId pulumi.StringInput + // The network, that is reachable though the Next Hop. Should use CIDR notation. + Prefix pulumi.StringInput +} + +func (NetworkAreaRouteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*networkAreaRouteArgs)(nil)).Elem() +} + +type NetworkAreaRouteInput interface { + pulumi.Input + + ToNetworkAreaRouteOutput() NetworkAreaRouteOutput + ToNetworkAreaRouteOutputWithContext(ctx context.Context) NetworkAreaRouteOutput +} + +func (*NetworkAreaRoute) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkAreaRoute)(nil)).Elem() +} + +func (i *NetworkAreaRoute) ToNetworkAreaRouteOutput() NetworkAreaRouteOutput { + return i.ToNetworkAreaRouteOutputWithContext(context.Background()) +} + +func (i *NetworkAreaRoute) ToNetworkAreaRouteOutputWithContext(ctx context.Context) NetworkAreaRouteOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaRouteOutput) +} + +// NetworkAreaRouteArrayInput is an input type that accepts NetworkAreaRouteArray and NetworkAreaRouteArrayOutput values. +// You can construct a concrete instance of `NetworkAreaRouteArrayInput` via: +// +// NetworkAreaRouteArray{ NetworkAreaRouteArgs{...} } +type NetworkAreaRouteArrayInput interface { + pulumi.Input + + ToNetworkAreaRouteArrayOutput() NetworkAreaRouteArrayOutput + ToNetworkAreaRouteArrayOutputWithContext(context.Context) NetworkAreaRouteArrayOutput +} + +type NetworkAreaRouteArray []NetworkAreaRouteInput + +func (NetworkAreaRouteArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkAreaRoute)(nil)).Elem() +} + +func (i NetworkAreaRouteArray) ToNetworkAreaRouteArrayOutput() NetworkAreaRouteArrayOutput { + return i.ToNetworkAreaRouteArrayOutputWithContext(context.Background()) +} + +func (i NetworkAreaRouteArray) ToNetworkAreaRouteArrayOutputWithContext(ctx context.Context) NetworkAreaRouteArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaRouteArrayOutput) +} + +// NetworkAreaRouteMapInput is an input type that accepts NetworkAreaRouteMap and NetworkAreaRouteMapOutput values. +// You can construct a concrete instance of `NetworkAreaRouteMapInput` via: +// +// NetworkAreaRouteMap{ "key": NetworkAreaRouteArgs{...} } +type NetworkAreaRouteMapInput interface { + pulumi.Input + + ToNetworkAreaRouteMapOutput() NetworkAreaRouteMapOutput + ToNetworkAreaRouteMapOutputWithContext(context.Context) NetworkAreaRouteMapOutput +} + +type NetworkAreaRouteMap map[string]NetworkAreaRouteInput + +func (NetworkAreaRouteMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkAreaRoute)(nil)).Elem() +} + +func (i NetworkAreaRouteMap) ToNetworkAreaRouteMapOutput() NetworkAreaRouteMapOutput { + return i.ToNetworkAreaRouteMapOutputWithContext(context.Background()) +} + +func (i NetworkAreaRouteMap) ToNetworkAreaRouteMapOutputWithContext(ctx context.Context) NetworkAreaRouteMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaRouteMapOutput) +} + +type NetworkAreaRouteOutput struct{ *pulumi.OutputState } + +func (NetworkAreaRouteOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkAreaRoute)(nil)).Elem() +} + +func (o NetworkAreaRouteOutput) ToNetworkAreaRouteOutput() NetworkAreaRouteOutput { + return o +} + +func (o NetworkAreaRouteOutput) ToNetworkAreaRouteOutputWithContext(ctx context.Context) NetworkAreaRouteOutput { + return o +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o NetworkAreaRouteOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The network area ID to which the network area route is associated. +func (o NetworkAreaRouteOutput) NetworkAreaId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringOutput { return v.NetworkAreaId }).(pulumi.StringOutput) +} + +// The network area route ID. +func (o NetworkAreaRouteOutput) NetworkAreaRouteId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringOutput { return v.NetworkAreaRouteId }).(pulumi.StringOutput) +} + +// The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. +func (o NetworkAreaRouteOutput) NextHop() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringOutput { return v.NextHop }).(pulumi.StringOutput) +} + +// STACKIT organization ID to which the network area is associated. +func (o NetworkAreaRouteOutput) OrganizationId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput) +} + +// The network, that is reachable though the Next Hop. Should use CIDR notation. +func (o NetworkAreaRouteOutput) Prefix() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkAreaRoute) pulumi.StringOutput { return v.Prefix }).(pulumi.StringOutput) +} + +type NetworkAreaRouteArrayOutput struct{ *pulumi.OutputState } + +func (NetworkAreaRouteArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkAreaRoute)(nil)).Elem() +} + +func (o NetworkAreaRouteArrayOutput) ToNetworkAreaRouteArrayOutput() NetworkAreaRouteArrayOutput { + return o +} + +func (o NetworkAreaRouteArrayOutput) ToNetworkAreaRouteArrayOutputWithContext(ctx context.Context) NetworkAreaRouteArrayOutput { + return o +} + +func (o NetworkAreaRouteArrayOutput) Index(i pulumi.IntInput) NetworkAreaRouteOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkAreaRoute { + return vs[0].([]*NetworkAreaRoute)[vs[1].(int)] + }).(NetworkAreaRouteOutput) +} + +type NetworkAreaRouteMapOutput struct{ *pulumi.OutputState } + +func (NetworkAreaRouteMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkAreaRoute)(nil)).Elem() +} + +func (o NetworkAreaRouteMapOutput) ToNetworkAreaRouteMapOutput() NetworkAreaRouteMapOutput { + return o +} + +func (o NetworkAreaRouteMapOutput) ToNetworkAreaRouteMapOutputWithContext(ctx context.Context) NetworkAreaRouteMapOutput { + return o +} + +func (o NetworkAreaRouteMapOutput) MapIndex(k pulumi.StringInput) NetworkAreaRouteOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkAreaRoute { + return vs[0].(map[string]*NetworkAreaRoute)[vs[1].(string)] + }).(NetworkAreaRouteOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaRouteInput)(nil)).Elem(), &NetworkAreaRoute{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaRouteArrayInput)(nil)).Elem(), NetworkAreaRouteArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaRouteMapInput)(nil)).Elem(), NetworkAreaRouteMap{}) + pulumi.RegisterOutputType(NetworkAreaRouteOutput{}) + pulumi.RegisterOutputType(NetworkAreaRouteArrayOutput{}) + pulumi.RegisterOutputType(NetworkAreaRouteMapOutput{}) +} diff --git a/sdk/go/stackit/networkInterface.go b/sdk/go/stackit/networkInterface.go new file mode 100644 index 0000000..fb653ed --- /dev/null +++ b/sdk/go/stackit/networkInterface.go @@ -0,0 +1,373 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network interface resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type NetworkInterface struct { + pulumi.CustomResourceState + + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses pulumi.StringArrayOutput `pulumi:"allowedAddresses"` + // The device UUID of the network interface. + Device pulumi.StringOutput `pulumi:"device"` + // The IPv4 address. + Ipv4 pulumi.StringOutput `pulumi:"ipv4"` + // Labels are key-value string pairs which can be attached to a network interface. + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The MAC address of network interface. + Mac pulumi.StringOutput `pulumi:"mac"` + // The name of the network interface. + Name pulumi.StringOutput `pulumi:"name"` + // The network ID to which the network interface is associated. + NetworkId pulumi.StringOutput `pulumi:"networkId"` + // The network interface ID. + NetworkInterfaceId pulumi.StringOutput `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security pulumi.BoolOutput `pulumi:"security"` + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds pulumi.StringArrayOutput `pulumi:"securityGroupIds"` + // Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + Type pulumi.StringOutput `pulumi:"type"` +} + +// NewNetworkInterface registers a new resource with the given unique name, arguments, and options. +func NewNetworkInterface(ctx *pulumi.Context, + name string, args *NetworkInterfaceArgs, opts ...pulumi.ResourceOption) (*NetworkInterface, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NetworkId == nil { + return nil, errors.New("invalid value for required argument 'NetworkId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource NetworkInterface + err := ctx.RegisterResource("stackit:index/networkInterface:NetworkInterface", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetNetworkInterface gets an existing NetworkInterface 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 GetNetworkInterface(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *NetworkInterfaceState, opts ...pulumi.ResourceOption) (*NetworkInterface, error) { + var resource NetworkInterface + err := ctx.ReadResource("stackit:index/networkInterface:NetworkInterface", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering NetworkInterface resources. +type networkInterfaceState struct { + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses []string `pulumi:"allowedAddresses"` + // The device UUID of the network interface. + Device *string `pulumi:"device"` + // The IPv4 address. + Ipv4 *string `pulumi:"ipv4"` + // Labels are key-value string pairs which can be attached to a network interface. + Labels map[string]string `pulumi:"labels"` + // The MAC address of network interface. + Mac *string `pulumi:"mac"` + // The name of the network interface. + Name *string `pulumi:"name"` + // The network ID to which the network interface is associated. + NetworkId *string `pulumi:"networkId"` + // The network interface ID. + NetworkInterfaceId *string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network is associated. + ProjectId *string `pulumi:"projectId"` + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security *bool `pulumi:"security"` + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds []string `pulumi:"securityGroupIds"` + // Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + Type *string `pulumi:"type"` +} + +type NetworkInterfaceState struct { + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses pulumi.StringArrayInput + // The device UUID of the network interface. + Device pulumi.StringPtrInput + // The IPv4 address. + Ipv4 pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a network interface. + Labels pulumi.StringMapInput + // The MAC address of network interface. + Mac pulumi.StringPtrInput + // The name of the network interface. + Name pulumi.StringPtrInput + // The network ID to which the network interface is associated. + NetworkId pulumi.StringPtrInput + // The network interface ID. + NetworkInterfaceId pulumi.StringPtrInput + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringPtrInput + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security pulumi.BoolPtrInput + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds pulumi.StringArrayInput + // Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + Type pulumi.StringPtrInput +} + +func (NetworkInterfaceState) ElementType() reflect.Type { + return reflect.TypeOf((*networkInterfaceState)(nil)).Elem() +} + +type networkInterfaceArgs struct { + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses []string `pulumi:"allowedAddresses"` + // The IPv4 address. + Ipv4 *string `pulumi:"ipv4"` + // Labels are key-value string pairs which can be attached to a network interface. + Labels map[string]string `pulumi:"labels"` + // The name of the network interface. + Name *string `pulumi:"name"` + // The network ID to which the network interface is associated. + NetworkId string `pulumi:"networkId"` + // STACKIT project ID to which the network is associated. + ProjectId string `pulumi:"projectId"` + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security *bool `pulumi:"security"` + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds []string `pulumi:"securityGroupIds"` +} + +// The set of arguments for constructing a NetworkInterface resource. +type NetworkInterfaceArgs struct { + // The list of CIDR (Classless Inter-Domain Routing) notations. + AllowedAddresses pulumi.StringArrayInput + // The IPv4 address. + Ipv4 pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a network interface. + Labels pulumi.StringMapInput + // The name of the network interface. + Name pulumi.StringPtrInput + // The network ID to which the network interface is associated. + NetworkId pulumi.StringInput + // STACKIT project ID to which the network is associated. + ProjectId pulumi.StringInput + // The Network Interface Security. If set to false, then no security groups will apply to this network interface. + Security pulumi.BoolPtrInput + // The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + SecurityGroupIds pulumi.StringArrayInput +} + +func (NetworkInterfaceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*networkInterfaceArgs)(nil)).Elem() +} + +type NetworkInterfaceInput interface { + pulumi.Input + + ToNetworkInterfaceOutput() NetworkInterfaceOutput + ToNetworkInterfaceOutputWithContext(ctx context.Context) NetworkInterfaceOutput +} + +func (*NetworkInterface) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkInterface)(nil)).Elem() +} + +func (i *NetworkInterface) ToNetworkInterfaceOutput() NetworkInterfaceOutput { + return i.ToNetworkInterfaceOutputWithContext(context.Background()) +} + +func (i *NetworkInterface) ToNetworkInterfaceOutputWithContext(ctx context.Context) NetworkInterfaceOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkInterfaceOutput) +} + +// NetworkInterfaceArrayInput is an input type that accepts NetworkInterfaceArray and NetworkInterfaceArrayOutput values. +// You can construct a concrete instance of `NetworkInterfaceArrayInput` via: +// +// NetworkInterfaceArray{ NetworkInterfaceArgs{...} } +type NetworkInterfaceArrayInput interface { + pulumi.Input + + ToNetworkInterfaceArrayOutput() NetworkInterfaceArrayOutput + ToNetworkInterfaceArrayOutputWithContext(context.Context) NetworkInterfaceArrayOutput +} + +type NetworkInterfaceArray []NetworkInterfaceInput + +func (NetworkInterfaceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkInterface)(nil)).Elem() +} + +func (i NetworkInterfaceArray) ToNetworkInterfaceArrayOutput() NetworkInterfaceArrayOutput { + return i.ToNetworkInterfaceArrayOutputWithContext(context.Background()) +} + +func (i NetworkInterfaceArray) ToNetworkInterfaceArrayOutputWithContext(ctx context.Context) NetworkInterfaceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkInterfaceArrayOutput) +} + +// NetworkInterfaceMapInput is an input type that accepts NetworkInterfaceMap and NetworkInterfaceMapOutput values. +// You can construct a concrete instance of `NetworkInterfaceMapInput` via: +// +// NetworkInterfaceMap{ "key": NetworkInterfaceArgs{...} } +type NetworkInterfaceMapInput interface { + pulumi.Input + + ToNetworkInterfaceMapOutput() NetworkInterfaceMapOutput + ToNetworkInterfaceMapOutputWithContext(context.Context) NetworkInterfaceMapOutput +} + +type NetworkInterfaceMap map[string]NetworkInterfaceInput + +func (NetworkInterfaceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkInterface)(nil)).Elem() +} + +func (i NetworkInterfaceMap) ToNetworkInterfaceMapOutput() NetworkInterfaceMapOutput { + return i.ToNetworkInterfaceMapOutputWithContext(context.Background()) +} + +func (i NetworkInterfaceMap) ToNetworkInterfaceMapOutputWithContext(ctx context.Context) NetworkInterfaceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkInterfaceMapOutput) +} + +type NetworkInterfaceOutput struct{ *pulumi.OutputState } + +func (NetworkInterfaceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**NetworkInterface)(nil)).Elem() +} + +func (o NetworkInterfaceOutput) ToNetworkInterfaceOutput() NetworkInterfaceOutput { + return o +} + +func (o NetworkInterfaceOutput) ToNetworkInterfaceOutputWithContext(ctx context.Context) NetworkInterfaceOutput { + return o +} + +// The list of CIDR (Classless Inter-Domain Routing) notations. +func (o NetworkInterfaceOutput) AllowedAddresses() pulumi.StringArrayOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringArrayOutput { return v.AllowedAddresses }).(pulumi.StringArrayOutput) +} + +// The device UUID of the network interface. +func (o NetworkInterfaceOutput) Device() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.Device }).(pulumi.StringOutput) +} + +// The IPv4 address. +func (o NetworkInterfaceOutput) Ipv4() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.Ipv4 }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a network interface. +func (o NetworkInterfaceOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The MAC address of network interface. +func (o NetworkInterfaceOutput) Mac() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.Mac }).(pulumi.StringOutput) +} + +// The name of the network interface. +func (o NetworkInterfaceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The network ID to which the network interface is associated. +func (o NetworkInterfaceOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.NetworkId }).(pulumi.StringOutput) +} + +// The network interface ID. +func (o NetworkInterfaceOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the network is associated. +func (o NetworkInterfaceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The Network Interface Security. If set to false, then no security groups will apply to this network interface. +func (o NetworkInterfaceOutput) Security() pulumi.BoolOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.BoolOutput { return v.Security }).(pulumi.BoolOutput) +} + +// The list of security group UUIDs. If security is set to false, setting this field will lead to an error. +func (o NetworkInterfaceOutput) SecurityGroupIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringArrayOutput { return v.SecurityGroupIds }).(pulumi.StringArrayOutput) +} + +// Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. +func (o NetworkInterfaceOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v *NetworkInterface) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput) +} + +type NetworkInterfaceArrayOutput struct{ *pulumi.OutputState } + +func (NetworkInterfaceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*NetworkInterface)(nil)).Elem() +} + +func (o NetworkInterfaceArrayOutput) ToNetworkInterfaceArrayOutput() NetworkInterfaceArrayOutput { + return o +} + +func (o NetworkInterfaceArrayOutput) ToNetworkInterfaceArrayOutputWithContext(ctx context.Context) NetworkInterfaceArrayOutput { + return o +} + +func (o NetworkInterfaceArrayOutput) Index(i pulumi.IntInput) NetworkInterfaceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *NetworkInterface { + return vs[0].([]*NetworkInterface)[vs[1].(int)] + }).(NetworkInterfaceOutput) +} + +type NetworkInterfaceMapOutput struct{ *pulumi.OutputState } + +func (NetworkInterfaceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*NetworkInterface)(nil)).Elem() +} + +func (o NetworkInterfaceMapOutput) ToNetworkInterfaceMapOutput() NetworkInterfaceMapOutput { + return o +} + +func (o NetworkInterfaceMapOutput) ToNetworkInterfaceMapOutputWithContext(ctx context.Context) NetworkInterfaceMapOutput { + return o +} + +func (o NetworkInterfaceMapOutput) MapIndex(k pulumi.StringInput) NetworkInterfaceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *NetworkInterface { + return vs[0].(map[string]*NetworkInterface)[vs[1].(string)] + }).(NetworkInterfaceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*NetworkInterfaceInput)(nil)).Elem(), &NetworkInterface{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkInterfaceArrayInput)(nil)).Elem(), NetworkInterfaceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkInterfaceMapInput)(nil)).Elem(), NetworkInterfaceMap{}) + pulumi.RegisterOutputType(NetworkInterfaceOutput{}) + pulumi.RegisterOutputType(NetworkInterfaceArrayOutput{}) + pulumi.RegisterOutputType(NetworkInterfaceMapOutput{}) +} diff --git a/sdk/go/stackit/objectstorageBucket.go b/sdk/go/stackit/objectstorageBucket.go new file mode 100644 index 0000000..ae1a6a7 --- /dev/null +++ b/sdk/go/stackit/objectstorageBucket.go @@ -0,0 +1,265 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `dependsOn` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. +// +// ## Example Usage +type ObjectstorageBucket struct { + pulumi.CustomResourceState + + // The bucket name. It must be DNS conform. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + UrlPathStyle pulumi.StringOutput `pulumi:"urlPathStyle"` + UrlVirtualHostedStyle pulumi.StringOutput `pulumi:"urlVirtualHostedStyle"` +} + +// NewObjectstorageBucket registers a new resource with the given unique name, arguments, and options. +func NewObjectstorageBucket(ctx *pulumi.Context, + name string, args *ObjectstorageBucketArgs, opts ...pulumi.ResourceOption) (*ObjectstorageBucket, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObjectstorageBucket + err := ctx.RegisterResource("stackit:index/objectstorageBucket:ObjectstorageBucket", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObjectstorageBucket gets an existing ObjectstorageBucket 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 GetObjectstorageBucket(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObjectstorageBucketState, opts ...pulumi.ResourceOption) (*ObjectstorageBucket, error) { + var resource ObjectstorageBucket + err := ctx.ReadResource("stackit:index/objectstorageBucket:ObjectstorageBucket", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObjectstorageBucket resources. +type objectstorageBucketState struct { + // The bucket name. It must be DNS conform. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + UrlPathStyle *string `pulumi:"urlPathStyle"` + UrlVirtualHostedStyle *string `pulumi:"urlVirtualHostedStyle"` +} + +type ObjectstorageBucketState struct { + // The bucket name. It must be DNS conform. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the bucket is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + UrlPathStyle pulumi.StringPtrInput + UrlVirtualHostedStyle pulumi.StringPtrInput +} + +func (ObjectstorageBucketState) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageBucketState)(nil)).Elem() +} + +type objectstorageBucketArgs struct { + // The bucket name. It must be DNS conform. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the bucket is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// The set of arguments for constructing a ObjectstorageBucket resource. +type ObjectstorageBucketArgs struct { + // The bucket name. It must be DNS conform. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the bucket is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (ObjectstorageBucketArgs) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageBucketArgs)(nil)).Elem() +} + +type ObjectstorageBucketInput interface { + pulumi.Input + + ToObjectstorageBucketOutput() ObjectstorageBucketOutput + ToObjectstorageBucketOutputWithContext(ctx context.Context) ObjectstorageBucketOutput +} + +func (*ObjectstorageBucket) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageBucket)(nil)).Elem() +} + +func (i *ObjectstorageBucket) ToObjectstorageBucketOutput() ObjectstorageBucketOutput { + return i.ToObjectstorageBucketOutputWithContext(context.Background()) +} + +func (i *ObjectstorageBucket) ToObjectstorageBucketOutputWithContext(ctx context.Context) ObjectstorageBucketOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageBucketOutput) +} + +// ObjectstorageBucketArrayInput is an input type that accepts ObjectstorageBucketArray and ObjectstorageBucketArrayOutput values. +// You can construct a concrete instance of `ObjectstorageBucketArrayInput` via: +// +// ObjectstorageBucketArray{ ObjectstorageBucketArgs{...} } +type ObjectstorageBucketArrayInput interface { + pulumi.Input + + ToObjectstorageBucketArrayOutput() ObjectstorageBucketArrayOutput + ToObjectstorageBucketArrayOutputWithContext(context.Context) ObjectstorageBucketArrayOutput +} + +type ObjectstorageBucketArray []ObjectstorageBucketInput + +func (ObjectstorageBucketArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageBucket)(nil)).Elem() +} + +func (i ObjectstorageBucketArray) ToObjectstorageBucketArrayOutput() ObjectstorageBucketArrayOutput { + return i.ToObjectstorageBucketArrayOutputWithContext(context.Background()) +} + +func (i ObjectstorageBucketArray) ToObjectstorageBucketArrayOutputWithContext(ctx context.Context) ObjectstorageBucketArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageBucketArrayOutput) +} + +// ObjectstorageBucketMapInput is an input type that accepts ObjectstorageBucketMap and ObjectstorageBucketMapOutput values. +// You can construct a concrete instance of `ObjectstorageBucketMapInput` via: +// +// ObjectstorageBucketMap{ "key": ObjectstorageBucketArgs{...} } +type ObjectstorageBucketMapInput interface { + pulumi.Input + + ToObjectstorageBucketMapOutput() ObjectstorageBucketMapOutput + ToObjectstorageBucketMapOutputWithContext(context.Context) ObjectstorageBucketMapOutput +} + +type ObjectstorageBucketMap map[string]ObjectstorageBucketInput + +func (ObjectstorageBucketMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageBucket)(nil)).Elem() +} + +func (i ObjectstorageBucketMap) ToObjectstorageBucketMapOutput() ObjectstorageBucketMapOutput { + return i.ToObjectstorageBucketMapOutputWithContext(context.Background()) +} + +func (i ObjectstorageBucketMap) ToObjectstorageBucketMapOutputWithContext(ctx context.Context) ObjectstorageBucketMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageBucketMapOutput) +} + +type ObjectstorageBucketOutput struct{ *pulumi.OutputState } + +func (ObjectstorageBucketOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageBucket)(nil)).Elem() +} + +func (o ObjectstorageBucketOutput) ToObjectstorageBucketOutput() ObjectstorageBucketOutput { + return o +} + +func (o ObjectstorageBucketOutput) ToObjectstorageBucketOutputWithContext(ctx context.Context) ObjectstorageBucketOutput { + return o +} + +// The bucket name. It must be DNS conform. +func (o ObjectstorageBucketOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageBucket) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the bucket is associated. +func (o ObjectstorageBucketOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageBucket) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o ObjectstorageBucketOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageBucket) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +func (o ObjectstorageBucketOutput) UrlPathStyle() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageBucket) pulumi.StringOutput { return v.UrlPathStyle }).(pulumi.StringOutput) +} + +func (o ObjectstorageBucketOutput) UrlVirtualHostedStyle() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageBucket) pulumi.StringOutput { return v.UrlVirtualHostedStyle }).(pulumi.StringOutput) +} + +type ObjectstorageBucketArrayOutput struct{ *pulumi.OutputState } + +func (ObjectstorageBucketArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageBucket)(nil)).Elem() +} + +func (o ObjectstorageBucketArrayOutput) ToObjectstorageBucketArrayOutput() ObjectstorageBucketArrayOutput { + return o +} + +func (o ObjectstorageBucketArrayOutput) ToObjectstorageBucketArrayOutputWithContext(ctx context.Context) ObjectstorageBucketArrayOutput { + return o +} + +func (o ObjectstorageBucketArrayOutput) Index(i pulumi.IntInput) ObjectstorageBucketOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObjectstorageBucket { + return vs[0].([]*ObjectstorageBucket)[vs[1].(int)] + }).(ObjectstorageBucketOutput) +} + +type ObjectstorageBucketMapOutput struct{ *pulumi.OutputState } + +func (ObjectstorageBucketMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageBucket)(nil)).Elem() +} + +func (o ObjectstorageBucketMapOutput) ToObjectstorageBucketMapOutput() ObjectstorageBucketMapOutput { + return o +} + +func (o ObjectstorageBucketMapOutput) ToObjectstorageBucketMapOutputWithContext(ctx context.Context) ObjectstorageBucketMapOutput { + return o +} + +func (o ObjectstorageBucketMapOutput) MapIndex(k pulumi.StringInput) ObjectstorageBucketOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObjectstorageBucket { + return vs[0].(map[string]*ObjectstorageBucket)[vs[1].(string)] + }).(ObjectstorageBucketOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageBucketInput)(nil)).Elem(), &ObjectstorageBucket{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageBucketArrayInput)(nil)).Elem(), ObjectstorageBucketArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageBucketMapInput)(nil)).Elem(), ObjectstorageBucketMap{}) + pulumi.RegisterOutputType(ObjectstorageBucketOutput{}) + pulumi.RegisterOutputType(ObjectstorageBucketArrayOutput{}) + pulumi.RegisterOutputType(ObjectstorageBucketMapOutput{}) +} diff --git a/sdk/go/stackit/objectstorageCredential.go b/sdk/go/stackit/objectstorageCredential.go new file mode 100644 index 0000000..3c05fe7 --- /dev/null +++ b/sdk/go/stackit/objectstorageCredential.go @@ -0,0 +1,305 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObjectstorageCredential struct { + pulumi.CustomResourceState + + AccessKey pulumi.StringOutput `pulumi:"accessKey"` + // The credential ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + // The credential group ID. + CredentialsGroupId pulumi.StringOutput `pulumi:"credentialsGroupId"` + // Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + ExpirationTimestamp pulumi.StringOutput `pulumi:"expirationTimestamp"` + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT Project ID to which the credential group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + SecretAccessKey pulumi.StringOutput `pulumi:"secretAccessKey"` +} + +// NewObjectstorageCredential registers a new resource with the given unique name, arguments, and options. +func NewObjectstorageCredential(ctx *pulumi.Context, + name string, args *ObjectstorageCredentialArgs, opts ...pulumi.ResourceOption) (*ObjectstorageCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.CredentialsGroupId == nil { + return nil, errors.New("invalid value for required argument 'CredentialsGroupId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "secretAccessKey", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObjectstorageCredential + err := ctx.RegisterResource("stackit:index/objectstorageCredential:ObjectstorageCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObjectstorageCredential gets an existing ObjectstorageCredential 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 GetObjectstorageCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObjectstorageCredentialState, opts ...pulumi.ResourceOption) (*ObjectstorageCredential, error) { + var resource ObjectstorageCredential + err := ctx.ReadResource("stackit:index/objectstorageCredential:ObjectstorageCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObjectstorageCredential resources. +type objectstorageCredentialState struct { + AccessKey *string `pulumi:"accessKey"` + // The credential ID. + CredentialId *string `pulumi:"credentialId"` + // The credential group ID. + CredentialsGroupId *string `pulumi:"credentialsGroupId"` + // Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + ExpirationTimestamp *string `pulumi:"expirationTimestamp"` + Name *string `pulumi:"name"` + // STACKIT Project ID to which the credential group is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + SecretAccessKey *string `pulumi:"secretAccessKey"` +} + +type ObjectstorageCredentialState struct { + AccessKey pulumi.StringPtrInput + // The credential ID. + CredentialId pulumi.StringPtrInput + // The credential group ID. + CredentialsGroupId pulumi.StringPtrInput + // Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + ExpirationTimestamp pulumi.StringPtrInput + Name pulumi.StringPtrInput + // STACKIT Project ID to which the credential group is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + SecretAccessKey pulumi.StringPtrInput +} + +func (ObjectstorageCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageCredentialState)(nil)).Elem() +} + +type objectstorageCredentialArgs struct { + // The credential group ID. + CredentialsGroupId string `pulumi:"credentialsGroupId"` + // Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + ExpirationTimestamp *string `pulumi:"expirationTimestamp"` + // STACKIT Project ID to which the credential group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// The set of arguments for constructing a ObjectstorageCredential resource. +type ObjectstorageCredentialArgs struct { + // The credential group ID. + CredentialsGroupId pulumi.StringInput + // Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + ExpirationTimestamp pulumi.StringPtrInput + // STACKIT Project ID to which the credential group is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (ObjectstorageCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageCredentialArgs)(nil)).Elem() +} + +type ObjectstorageCredentialInput interface { + pulumi.Input + + ToObjectstorageCredentialOutput() ObjectstorageCredentialOutput + ToObjectstorageCredentialOutputWithContext(ctx context.Context) ObjectstorageCredentialOutput +} + +func (*ObjectstorageCredential) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageCredential)(nil)).Elem() +} + +func (i *ObjectstorageCredential) ToObjectstorageCredentialOutput() ObjectstorageCredentialOutput { + return i.ToObjectstorageCredentialOutputWithContext(context.Background()) +} + +func (i *ObjectstorageCredential) ToObjectstorageCredentialOutputWithContext(ctx context.Context) ObjectstorageCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialOutput) +} + +// ObjectstorageCredentialArrayInput is an input type that accepts ObjectstorageCredentialArray and ObjectstorageCredentialArrayOutput values. +// You can construct a concrete instance of `ObjectstorageCredentialArrayInput` via: +// +// ObjectstorageCredentialArray{ ObjectstorageCredentialArgs{...} } +type ObjectstorageCredentialArrayInput interface { + pulumi.Input + + ToObjectstorageCredentialArrayOutput() ObjectstorageCredentialArrayOutput + ToObjectstorageCredentialArrayOutputWithContext(context.Context) ObjectstorageCredentialArrayOutput +} + +type ObjectstorageCredentialArray []ObjectstorageCredentialInput + +func (ObjectstorageCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageCredential)(nil)).Elem() +} + +func (i ObjectstorageCredentialArray) ToObjectstorageCredentialArrayOutput() ObjectstorageCredentialArrayOutput { + return i.ToObjectstorageCredentialArrayOutputWithContext(context.Background()) +} + +func (i ObjectstorageCredentialArray) ToObjectstorageCredentialArrayOutputWithContext(ctx context.Context) ObjectstorageCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialArrayOutput) +} + +// ObjectstorageCredentialMapInput is an input type that accepts ObjectstorageCredentialMap and ObjectstorageCredentialMapOutput values. +// You can construct a concrete instance of `ObjectstorageCredentialMapInput` via: +// +// ObjectstorageCredentialMap{ "key": ObjectstorageCredentialArgs{...} } +type ObjectstorageCredentialMapInput interface { + pulumi.Input + + ToObjectstorageCredentialMapOutput() ObjectstorageCredentialMapOutput + ToObjectstorageCredentialMapOutputWithContext(context.Context) ObjectstorageCredentialMapOutput +} + +type ObjectstorageCredentialMap map[string]ObjectstorageCredentialInput + +func (ObjectstorageCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageCredential)(nil)).Elem() +} + +func (i ObjectstorageCredentialMap) ToObjectstorageCredentialMapOutput() ObjectstorageCredentialMapOutput { + return i.ToObjectstorageCredentialMapOutputWithContext(context.Background()) +} + +func (i ObjectstorageCredentialMap) ToObjectstorageCredentialMapOutputWithContext(ctx context.Context) ObjectstorageCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialMapOutput) +} + +type ObjectstorageCredentialOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageCredential)(nil)).Elem() +} + +func (o ObjectstorageCredentialOutput) ToObjectstorageCredentialOutput() ObjectstorageCredentialOutput { + return o +} + +func (o ObjectstorageCredentialOutput) ToObjectstorageCredentialOutputWithContext(ctx context.Context) ObjectstorageCredentialOutput { + return o +} + +func (o ObjectstorageCredentialOutput) AccessKey() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.AccessKey }).(pulumi.StringOutput) +} + +// The credential ID. +func (o ObjectstorageCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +// The credential group ID. +func (o ObjectstorageCredentialOutput) CredentialsGroupId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.CredentialsGroupId }).(pulumi.StringOutput) +} + +// Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. +func (o ObjectstorageCredentialOutput) ExpirationTimestamp() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.ExpirationTimestamp }).(pulumi.StringOutput) +} + +func (o ObjectstorageCredentialOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the credential group is associated. +func (o ObjectstorageCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o ObjectstorageCredentialOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +func (o ObjectstorageCredentialOutput) SecretAccessKey() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredential) pulumi.StringOutput { return v.SecretAccessKey }).(pulumi.StringOutput) +} + +type ObjectstorageCredentialArrayOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageCredential)(nil)).Elem() +} + +func (o ObjectstorageCredentialArrayOutput) ToObjectstorageCredentialArrayOutput() ObjectstorageCredentialArrayOutput { + return o +} + +func (o ObjectstorageCredentialArrayOutput) ToObjectstorageCredentialArrayOutputWithContext(ctx context.Context) ObjectstorageCredentialArrayOutput { + return o +} + +func (o ObjectstorageCredentialArrayOutput) Index(i pulumi.IntInput) ObjectstorageCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObjectstorageCredential { + return vs[0].([]*ObjectstorageCredential)[vs[1].(int)] + }).(ObjectstorageCredentialOutput) +} + +type ObjectstorageCredentialMapOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageCredential)(nil)).Elem() +} + +func (o ObjectstorageCredentialMapOutput) ToObjectstorageCredentialMapOutput() ObjectstorageCredentialMapOutput { + return o +} + +func (o ObjectstorageCredentialMapOutput) ToObjectstorageCredentialMapOutputWithContext(ctx context.Context) ObjectstorageCredentialMapOutput { + return o +} + +func (o ObjectstorageCredentialMapOutput) MapIndex(k pulumi.StringInput) ObjectstorageCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObjectstorageCredential { + return vs[0].(map[string]*ObjectstorageCredential)[vs[1].(string)] + }).(ObjectstorageCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialInput)(nil)).Elem(), &ObjectstorageCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialArrayInput)(nil)).Elem(), ObjectstorageCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialMapInput)(nil)).Elem(), ObjectstorageCredentialMap{}) + pulumi.RegisterOutputType(ObjectstorageCredentialOutput{}) + pulumi.RegisterOutputType(ObjectstorageCredentialArrayOutput{}) + pulumi.RegisterOutputType(ObjectstorageCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/objectstorageCredentialsGroup.go b/sdk/go/stackit/objectstorageCredentialsGroup.go new file mode 100644 index 0000000..fa774f2 --- /dev/null +++ b/sdk/go/stackit/objectstorageCredentialsGroup.go @@ -0,0 +1,273 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `dependsOn` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. +// +// ## Example Usage +type ObjectstorageCredentialsGroup struct { + pulumi.CustomResourceState + + // The credentials group ID + CredentialsGroupId pulumi.StringOutput `pulumi:"credentialsGroupId"` + // The credentials group's display name. + Name pulumi.StringOutput `pulumi:"name"` + // Project ID to which the credentials group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // Credentials group uniform resource name (URN) + Urn pulumi.StringOutput `pulumi:"urn"` +} + +// NewObjectstorageCredentialsGroup registers a new resource with the given unique name, arguments, and options. +func NewObjectstorageCredentialsGroup(ctx *pulumi.Context, + name string, args *ObjectstorageCredentialsGroupArgs, opts ...pulumi.ResourceOption) (*ObjectstorageCredentialsGroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObjectstorageCredentialsGroup + err := ctx.RegisterResource("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObjectstorageCredentialsGroup gets an existing ObjectstorageCredentialsGroup 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 GetObjectstorageCredentialsGroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObjectstorageCredentialsGroupState, opts ...pulumi.ResourceOption) (*ObjectstorageCredentialsGroup, error) { + var resource ObjectstorageCredentialsGroup + err := ctx.ReadResource("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObjectstorageCredentialsGroup resources. +type objectstorageCredentialsGroupState struct { + // The credentials group ID + CredentialsGroupId *string `pulumi:"credentialsGroupId"` + // The credentials group's display name. + Name *string `pulumi:"name"` + // Project ID to which the credentials group is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Credentials group uniform resource name (URN) + Urn *string `pulumi:"urn"` +} + +type ObjectstorageCredentialsGroupState struct { + // The credentials group ID + CredentialsGroupId pulumi.StringPtrInput + // The credentials group's display name. + Name pulumi.StringPtrInput + // Project ID to which the credentials group is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Credentials group uniform resource name (URN) + Urn pulumi.StringPtrInput +} + +func (ObjectstorageCredentialsGroupState) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageCredentialsGroupState)(nil)).Elem() +} + +type objectstorageCredentialsGroupArgs struct { + // The credentials group's display name. + Name *string `pulumi:"name"` + // Project ID to which the credentials group is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// The set of arguments for constructing a ObjectstorageCredentialsGroup resource. +type ObjectstorageCredentialsGroupArgs struct { + // The credentials group's display name. + Name pulumi.StringPtrInput + // Project ID to which the credentials group is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (ObjectstorageCredentialsGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*objectstorageCredentialsGroupArgs)(nil)).Elem() +} + +type ObjectstorageCredentialsGroupInput interface { + pulumi.Input + + ToObjectstorageCredentialsGroupOutput() ObjectstorageCredentialsGroupOutput + ToObjectstorageCredentialsGroupOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupOutput +} + +func (*ObjectstorageCredentialsGroup) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (i *ObjectstorageCredentialsGroup) ToObjectstorageCredentialsGroupOutput() ObjectstorageCredentialsGroupOutput { + return i.ToObjectstorageCredentialsGroupOutputWithContext(context.Background()) +} + +func (i *ObjectstorageCredentialsGroup) ToObjectstorageCredentialsGroupOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialsGroupOutput) +} + +// ObjectstorageCredentialsGroupArrayInput is an input type that accepts ObjectstorageCredentialsGroupArray and ObjectstorageCredentialsGroupArrayOutput values. +// You can construct a concrete instance of `ObjectstorageCredentialsGroupArrayInput` via: +// +// ObjectstorageCredentialsGroupArray{ ObjectstorageCredentialsGroupArgs{...} } +type ObjectstorageCredentialsGroupArrayInput interface { + pulumi.Input + + ToObjectstorageCredentialsGroupArrayOutput() ObjectstorageCredentialsGroupArrayOutput + ToObjectstorageCredentialsGroupArrayOutputWithContext(context.Context) ObjectstorageCredentialsGroupArrayOutput +} + +type ObjectstorageCredentialsGroupArray []ObjectstorageCredentialsGroupInput + +func (ObjectstorageCredentialsGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (i ObjectstorageCredentialsGroupArray) ToObjectstorageCredentialsGroupArrayOutput() ObjectstorageCredentialsGroupArrayOutput { + return i.ToObjectstorageCredentialsGroupArrayOutputWithContext(context.Background()) +} + +func (i ObjectstorageCredentialsGroupArray) ToObjectstorageCredentialsGroupArrayOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialsGroupArrayOutput) +} + +// ObjectstorageCredentialsGroupMapInput is an input type that accepts ObjectstorageCredentialsGroupMap and ObjectstorageCredentialsGroupMapOutput values. +// You can construct a concrete instance of `ObjectstorageCredentialsGroupMapInput` via: +// +// ObjectstorageCredentialsGroupMap{ "key": ObjectstorageCredentialsGroupArgs{...} } +type ObjectstorageCredentialsGroupMapInput interface { + pulumi.Input + + ToObjectstorageCredentialsGroupMapOutput() ObjectstorageCredentialsGroupMapOutput + ToObjectstorageCredentialsGroupMapOutputWithContext(context.Context) ObjectstorageCredentialsGroupMapOutput +} + +type ObjectstorageCredentialsGroupMap map[string]ObjectstorageCredentialsGroupInput + +func (ObjectstorageCredentialsGroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (i ObjectstorageCredentialsGroupMap) ToObjectstorageCredentialsGroupMapOutput() ObjectstorageCredentialsGroupMapOutput { + return i.ToObjectstorageCredentialsGroupMapOutputWithContext(context.Background()) +} + +func (i ObjectstorageCredentialsGroupMap) ToObjectstorageCredentialsGroupMapOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObjectstorageCredentialsGroupMapOutput) +} + +type ObjectstorageCredentialsGroupOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialsGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (o ObjectstorageCredentialsGroupOutput) ToObjectstorageCredentialsGroupOutput() ObjectstorageCredentialsGroupOutput { + return o +} + +func (o ObjectstorageCredentialsGroupOutput) ToObjectstorageCredentialsGroupOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupOutput { + return o +} + +// The credentials group ID +func (o ObjectstorageCredentialsGroupOutput) CredentialsGroupId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredentialsGroup) pulumi.StringOutput { return v.CredentialsGroupId }).(pulumi.StringOutput) +} + +// The credentials group's display name. +func (o ObjectstorageCredentialsGroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredentialsGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Project ID to which the credentials group is associated. +func (o ObjectstorageCredentialsGroupOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredentialsGroup) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o ObjectstorageCredentialsGroupOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredentialsGroup) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// Credentials group uniform resource name (URN) +func (o ObjectstorageCredentialsGroupOutput) Urn() pulumi.StringOutput { + return o.ApplyT(func(v *ObjectstorageCredentialsGroup) pulumi.StringOutput { return v.Urn }).(pulumi.StringOutput) +} + +type ObjectstorageCredentialsGroupArrayOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialsGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (o ObjectstorageCredentialsGroupArrayOutput) ToObjectstorageCredentialsGroupArrayOutput() ObjectstorageCredentialsGroupArrayOutput { + return o +} + +func (o ObjectstorageCredentialsGroupArrayOutput) ToObjectstorageCredentialsGroupArrayOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupArrayOutput { + return o +} + +func (o ObjectstorageCredentialsGroupArrayOutput) Index(i pulumi.IntInput) ObjectstorageCredentialsGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObjectstorageCredentialsGroup { + return vs[0].([]*ObjectstorageCredentialsGroup)[vs[1].(int)] + }).(ObjectstorageCredentialsGroupOutput) +} + +type ObjectstorageCredentialsGroupMapOutput struct{ *pulumi.OutputState } + +func (ObjectstorageCredentialsGroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObjectstorageCredentialsGroup)(nil)).Elem() +} + +func (o ObjectstorageCredentialsGroupMapOutput) ToObjectstorageCredentialsGroupMapOutput() ObjectstorageCredentialsGroupMapOutput { + return o +} + +func (o ObjectstorageCredentialsGroupMapOutput) ToObjectstorageCredentialsGroupMapOutputWithContext(ctx context.Context) ObjectstorageCredentialsGroupMapOutput { + return o +} + +func (o ObjectstorageCredentialsGroupMapOutput) MapIndex(k pulumi.StringInput) ObjectstorageCredentialsGroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObjectstorageCredentialsGroup { + return vs[0].(map[string]*ObjectstorageCredentialsGroup)[vs[1].(string)] + }).(ObjectstorageCredentialsGroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialsGroupInput)(nil)).Elem(), &ObjectstorageCredentialsGroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialsGroupArrayInput)(nil)).Elem(), ObjectstorageCredentialsGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObjectstorageCredentialsGroupMapInput)(nil)).Elem(), ObjectstorageCredentialsGroupMap{}) + pulumi.RegisterOutputType(ObjectstorageCredentialsGroupOutput{}) + pulumi.RegisterOutputType(ObjectstorageCredentialsGroupArrayOutput{}) + pulumi.RegisterOutputType(ObjectstorageCredentialsGroupMapOutput{}) +} diff --git a/sdk/go/stackit/observabilityAlertgroup.go b/sdk/go/stackit/observabilityAlertgroup.go new file mode 100644 index 0000000..0ed0bd2 --- /dev/null +++ b/sdk/go/stackit/observabilityAlertgroup.go @@ -0,0 +1,287 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObservabilityAlertgroup struct { + pulumi.CustomResourceState + + // Observability instance ID to which the alert group is associated. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringOutput `pulumi:"interval"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Rules for the alert group + Rules ObservabilityAlertgroupRuleArrayOutput `pulumi:"rules"` +} + +// NewObservabilityAlertgroup registers a new resource with the given unique name, arguments, and options. +func NewObservabilityAlertgroup(ctx *pulumi.Context, + name string, args *ObservabilityAlertgroupArgs, opts ...pulumi.ResourceOption) (*ObservabilityAlertgroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Rules == nil { + return nil, errors.New("invalid value for required argument 'Rules'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObservabilityAlertgroup + err := ctx.RegisterResource("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObservabilityAlertgroup gets an existing ObservabilityAlertgroup 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 GetObservabilityAlertgroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObservabilityAlertgroupState, opts ...pulumi.ResourceOption) (*ObservabilityAlertgroup, error) { + var resource ObservabilityAlertgroup + err := ctx.ReadResource("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObservabilityAlertgroup resources. +type observabilityAlertgroupState struct { + // Observability instance ID to which the alert group is associated. + InstanceId *string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval *string `pulumi:"interval"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId *string `pulumi:"projectId"` + // Rules for the alert group + Rules []ObservabilityAlertgroupRule `pulumi:"rules"` +} + +type ObservabilityAlertgroupState struct { + // Observability instance ID to which the alert group is associated. + InstanceId pulumi.StringPtrInput + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringPtrInput + // The name of the alert group. Is the identifier and must be unique in the group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the alert group is associated. + ProjectId pulumi.StringPtrInput + // Rules for the alert group + Rules ObservabilityAlertgroupRuleArrayInput +} + +func (ObservabilityAlertgroupState) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityAlertgroupState)(nil)).Elem() +} + +type observabilityAlertgroupArgs struct { + // Observability instance ID to which the alert group is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval *string `pulumi:"interval"` + // The name of the alert group. Is the identifier and must be unique in the group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the alert group is associated. + ProjectId string `pulumi:"projectId"` + // Rules for the alert group + Rules []ObservabilityAlertgroupRule `pulumi:"rules"` +} + +// The set of arguments for constructing a ObservabilityAlertgroup resource. +type ObservabilityAlertgroupArgs struct { + // Observability instance ID to which the alert group is associated. + InstanceId pulumi.StringInput + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringPtrInput + // The name of the alert group. Is the identifier and must be unique in the group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the alert group is associated. + ProjectId pulumi.StringInput + // Rules for the alert group + Rules ObservabilityAlertgroupRuleArrayInput +} + +func (ObservabilityAlertgroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityAlertgroupArgs)(nil)).Elem() +} + +type ObservabilityAlertgroupInput interface { + pulumi.Input + + ToObservabilityAlertgroupOutput() ObservabilityAlertgroupOutput + ToObservabilityAlertgroupOutputWithContext(ctx context.Context) ObservabilityAlertgroupOutput +} + +func (*ObservabilityAlertgroup) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityAlertgroup)(nil)).Elem() +} + +func (i *ObservabilityAlertgroup) ToObservabilityAlertgroupOutput() ObservabilityAlertgroupOutput { + return i.ToObservabilityAlertgroupOutputWithContext(context.Background()) +} + +func (i *ObservabilityAlertgroup) ToObservabilityAlertgroupOutputWithContext(ctx context.Context) ObservabilityAlertgroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityAlertgroupOutput) +} + +// ObservabilityAlertgroupArrayInput is an input type that accepts ObservabilityAlertgroupArray and ObservabilityAlertgroupArrayOutput values. +// You can construct a concrete instance of `ObservabilityAlertgroupArrayInput` via: +// +// ObservabilityAlertgroupArray{ ObservabilityAlertgroupArgs{...} } +type ObservabilityAlertgroupArrayInput interface { + pulumi.Input + + ToObservabilityAlertgroupArrayOutput() ObservabilityAlertgroupArrayOutput + ToObservabilityAlertgroupArrayOutputWithContext(context.Context) ObservabilityAlertgroupArrayOutput +} + +type ObservabilityAlertgroupArray []ObservabilityAlertgroupInput + +func (ObservabilityAlertgroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityAlertgroup)(nil)).Elem() +} + +func (i ObservabilityAlertgroupArray) ToObservabilityAlertgroupArrayOutput() ObservabilityAlertgroupArrayOutput { + return i.ToObservabilityAlertgroupArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityAlertgroupArray) ToObservabilityAlertgroupArrayOutputWithContext(ctx context.Context) ObservabilityAlertgroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityAlertgroupArrayOutput) +} + +// ObservabilityAlertgroupMapInput is an input type that accepts ObservabilityAlertgroupMap and ObservabilityAlertgroupMapOutput values. +// You can construct a concrete instance of `ObservabilityAlertgroupMapInput` via: +// +// ObservabilityAlertgroupMap{ "key": ObservabilityAlertgroupArgs{...} } +type ObservabilityAlertgroupMapInput interface { + pulumi.Input + + ToObservabilityAlertgroupMapOutput() ObservabilityAlertgroupMapOutput + ToObservabilityAlertgroupMapOutputWithContext(context.Context) ObservabilityAlertgroupMapOutput +} + +type ObservabilityAlertgroupMap map[string]ObservabilityAlertgroupInput + +func (ObservabilityAlertgroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityAlertgroup)(nil)).Elem() +} + +func (i ObservabilityAlertgroupMap) ToObservabilityAlertgroupMapOutput() ObservabilityAlertgroupMapOutput { + return i.ToObservabilityAlertgroupMapOutputWithContext(context.Background()) +} + +func (i ObservabilityAlertgroupMap) ToObservabilityAlertgroupMapOutputWithContext(ctx context.Context) ObservabilityAlertgroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityAlertgroupMapOutput) +} + +type ObservabilityAlertgroupOutput struct{ *pulumi.OutputState } + +func (ObservabilityAlertgroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityAlertgroup)(nil)).Elem() +} + +func (o ObservabilityAlertgroupOutput) ToObservabilityAlertgroupOutput() ObservabilityAlertgroupOutput { + return o +} + +func (o ObservabilityAlertgroupOutput) ToObservabilityAlertgroupOutputWithContext(ctx context.Context) ObservabilityAlertgroupOutput { + return o +} + +// Observability instance ID to which the alert group is associated. +func (o ObservabilityAlertgroupOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityAlertgroup) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. +func (o ObservabilityAlertgroupOutput) Interval() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityAlertgroup) pulumi.StringOutput { return v.Interval }).(pulumi.StringOutput) +} + +// The name of the alert group. Is the identifier and must be unique in the group. +func (o ObservabilityAlertgroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityAlertgroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the alert group is associated. +func (o ObservabilityAlertgroupOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityAlertgroup) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Rules for the alert group +func (o ObservabilityAlertgroupOutput) Rules() ObservabilityAlertgroupRuleArrayOutput { + return o.ApplyT(func(v *ObservabilityAlertgroup) ObservabilityAlertgroupRuleArrayOutput { return v.Rules }).(ObservabilityAlertgroupRuleArrayOutput) +} + +type ObservabilityAlertgroupArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityAlertgroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityAlertgroup)(nil)).Elem() +} + +func (o ObservabilityAlertgroupArrayOutput) ToObservabilityAlertgroupArrayOutput() ObservabilityAlertgroupArrayOutput { + return o +} + +func (o ObservabilityAlertgroupArrayOutput) ToObservabilityAlertgroupArrayOutputWithContext(ctx context.Context) ObservabilityAlertgroupArrayOutput { + return o +} + +func (o ObservabilityAlertgroupArrayOutput) Index(i pulumi.IntInput) ObservabilityAlertgroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObservabilityAlertgroup { + return vs[0].([]*ObservabilityAlertgroup)[vs[1].(int)] + }).(ObservabilityAlertgroupOutput) +} + +type ObservabilityAlertgroupMapOutput struct{ *pulumi.OutputState } + +func (ObservabilityAlertgroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityAlertgroup)(nil)).Elem() +} + +func (o ObservabilityAlertgroupMapOutput) ToObservabilityAlertgroupMapOutput() ObservabilityAlertgroupMapOutput { + return o +} + +func (o ObservabilityAlertgroupMapOutput) ToObservabilityAlertgroupMapOutputWithContext(ctx context.Context) ObservabilityAlertgroupMapOutput { + return o +} + +func (o ObservabilityAlertgroupMapOutput) MapIndex(k pulumi.StringInput) ObservabilityAlertgroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObservabilityAlertgroup { + return vs[0].(map[string]*ObservabilityAlertgroup)[vs[1].(string)] + }).(ObservabilityAlertgroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityAlertgroupInput)(nil)).Elem(), &ObservabilityAlertgroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityAlertgroupArrayInput)(nil)).Elem(), ObservabilityAlertgroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityAlertgroupMapInput)(nil)).Elem(), ObservabilityAlertgroupMap{}) + pulumi.RegisterOutputType(ObservabilityAlertgroupOutput{}) + pulumi.RegisterOutputType(ObservabilityAlertgroupArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityAlertgroupMapOutput{}) +} diff --git a/sdk/go/stackit/observabilityCredential.go b/sdk/go/stackit/observabilityCredential.go new file mode 100644 index 0000000..24aa9b1 --- /dev/null +++ b/sdk/go/stackit/observabilityCredential.go @@ -0,0 +1,265 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObservabilityCredential struct { + pulumi.CustomResourceState + + // The Observability Instance ID the credential belongs to. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Credential password + Password pulumi.StringOutput `pulumi:"password"` + // STACKIT project ID to which the credential is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Credential username + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewObservabilityCredential registers a new resource with the given unique name, arguments, and options. +func NewObservabilityCredential(ctx *pulumi.Context, + name string, args *ObservabilityCredentialArgs, opts ...pulumi.ResourceOption) (*ObservabilityCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObservabilityCredential + err := ctx.RegisterResource("stackit:index/observabilityCredential:ObservabilityCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObservabilityCredential gets an existing ObservabilityCredential 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 GetObservabilityCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObservabilityCredentialState, opts ...pulumi.ResourceOption) (*ObservabilityCredential, error) { + var resource ObservabilityCredential + err := ctx.ReadResource("stackit:index/observabilityCredential:ObservabilityCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObservabilityCredential resources. +type observabilityCredentialState struct { + // The Observability Instance ID the credential belongs to. + InstanceId *string `pulumi:"instanceId"` + // Credential password + Password *string `pulumi:"password"` + // STACKIT project ID to which the credential is associated. + ProjectId *string `pulumi:"projectId"` + // Credential username + Username *string `pulumi:"username"` +} + +type ObservabilityCredentialState struct { + // The Observability Instance ID the credential belongs to. + InstanceId pulumi.StringPtrInput + // Credential password + Password pulumi.StringPtrInput + // STACKIT project ID to which the credential is associated. + ProjectId pulumi.StringPtrInput + // Credential username + Username pulumi.StringPtrInput +} + +func (ObservabilityCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityCredentialState)(nil)).Elem() +} + +type observabilityCredentialArgs struct { + // The Observability Instance ID the credential belongs to. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the credential is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a ObservabilityCredential resource. +type ObservabilityCredentialArgs struct { + // The Observability Instance ID the credential belongs to. + InstanceId pulumi.StringInput + // STACKIT project ID to which the credential is associated. + ProjectId pulumi.StringInput +} + +func (ObservabilityCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityCredentialArgs)(nil)).Elem() +} + +type ObservabilityCredentialInput interface { + pulumi.Input + + ToObservabilityCredentialOutput() ObservabilityCredentialOutput + ToObservabilityCredentialOutputWithContext(ctx context.Context) ObservabilityCredentialOutput +} + +func (*ObservabilityCredential) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityCredential)(nil)).Elem() +} + +func (i *ObservabilityCredential) ToObservabilityCredentialOutput() ObservabilityCredentialOutput { + return i.ToObservabilityCredentialOutputWithContext(context.Background()) +} + +func (i *ObservabilityCredential) ToObservabilityCredentialOutputWithContext(ctx context.Context) ObservabilityCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityCredentialOutput) +} + +// ObservabilityCredentialArrayInput is an input type that accepts ObservabilityCredentialArray and ObservabilityCredentialArrayOutput values. +// You can construct a concrete instance of `ObservabilityCredentialArrayInput` via: +// +// ObservabilityCredentialArray{ ObservabilityCredentialArgs{...} } +type ObservabilityCredentialArrayInput interface { + pulumi.Input + + ToObservabilityCredentialArrayOutput() ObservabilityCredentialArrayOutput + ToObservabilityCredentialArrayOutputWithContext(context.Context) ObservabilityCredentialArrayOutput +} + +type ObservabilityCredentialArray []ObservabilityCredentialInput + +func (ObservabilityCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityCredential)(nil)).Elem() +} + +func (i ObservabilityCredentialArray) ToObservabilityCredentialArrayOutput() ObservabilityCredentialArrayOutput { + return i.ToObservabilityCredentialArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityCredentialArray) ToObservabilityCredentialArrayOutputWithContext(ctx context.Context) ObservabilityCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityCredentialArrayOutput) +} + +// ObservabilityCredentialMapInput is an input type that accepts ObservabilityCredentialMap and ObservabilityCredentialMapOutput values. +// You can construct a concrete instance of `ObservabilityCredentialMapInput` via: +// +// ObservabilityCredentialMap{ "key": ObservabilityCredentialArgs{...} } +type ObservabilityCredentialMapInput interface { + pulumi.Input + + ToObservabilityCredentialMapOutput() ObservabilityCredentialMapOutput + ToObservabilityCredentialMapOutputWithContext(context.Context) ObservabilityCredentialMapOutput +} + +type ObservabilityCredentialMap map[string]ObservabilityCredentialInput + +func (ObservabilityCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityCredential)(nil)).Elem() +} + +func (i ObservabilityCredentialMap) ToObservabilityCredentialMapOutput() ObservabilityCredentialMapOutput { + return i.ToObservabilityCredentialMapOutputWithContext(context.Background()) +} + +func (i ObservabilityCredentialMap) ToObservabilityCredentialMapOutputWithContext(ctx context.Context) ObservabilityCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityCredentialMapOutput) +} + +type ObservabilityCredentialOutput struct{ *pulumi.OutputState } + +func (ObservabilityCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityCredential)(nil)).Elem() +} + +func (o ObservabilityCredentialOutput) ToObservabilityCredentialOutput() ObservabilityCredentialOutput { + return o +} + +func (o ObservabilityCredentialOutput) ToObservabilityCredentialOutputWithContext(ctx context.Context) ObservabilityCredentialOutput { + return o +} + +// The Observability Instance ID the credential belongs to. +func (o ObservabilityCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Credential password +func (o ObservabilityCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the credential is associated. +func (o ObservabilityCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Credential username +func (o ObservabilityCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type ObservabilityCredentialArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityCredential)(nil)).Elem() +} + +func (o ObservabilityCredentialArrayOutput) ToObservabilityCredentialArrayOutput() ObservabilityCredentialArrayOutput { + return o +} + +func (o ObservabilityCredentialArrayOutput) ToObservabilityCredentialArrayOutputWithContext(ctx context.Context) ObservabilityCredentialArrayOutput { + return o +} + +func (o ObservabilityCredentialArrayOutput) Index(i pulumi.IntInput) ObservabilityCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObservabilityCredential { + return vs[0].([]*ObservabilityCredential)[vs[1].(int)] + }).(ObservabilityCredentialOutput) +} + +type ObservabilityCredentialMapOutput struct{ *pulumi.OutputState } + +func (ObservabilityCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityCredential)(nil)).Elem() +} + +func (o ObservabilityCredentialMapOutput) ToObservabilityCredentialMapOutput() ObservabilityCredentialMapOutput { + return o +} + +func (o ObservabilityCredentialMapOutput) ToObservabilityCredentialMapOutputWithContext(ctx context.Context) ObservabilityCredentialMapOutput { + return o +} + +func (o ObservabilityCredentialMapOutput) MapIndex(k pulumi.StringInput) ObservabilityCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObservabilityCredential { + return vs[0].(map[string]*ObservabilityCredential)[vs[1].(string)] + }).(ObservabilityCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityCredentialInput)(nil)).Elem(), &ObservabilityCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityCredentialArrayInput)(nil)).Elem(), ObservabilityCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityCredentialMapInput)(nil)).Elem(), ObservabilityCredentialMap{}) + pulumi.RegisterOutputType(ObservabilityCredentialOutput{}) + pulumi.RegisterOutputType(ObservabilityCredentialArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/observabilityInstance.go b/sdk/go/stackit/observabilityInstance.go new file mode 100644 index 0000000..bf80f26 --- /dev/null +++ b/sdk/go/stackit/observabilityInstance.go @@ -0,0 +1,530 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObservabilityInstance struct { + pulumi.CustomResourceState + + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls pulumi.StringArrayOutput `pulumi:"acls"` + // Alert configuration for the instance. + AlertConfig ObservabilityInstanceAlertConfigPtrOutput `pulumi:"alertConfig"` + // Specifies Alerting URL. + AlertingUrl pulumi.StringOutput `pulumi:"alertingUrl"` + // Specifies Observability instance dashboard URL. + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + // Specifies an initial Grafana admin password. + GrafanaInitialAdminPassword pulumi.StringOutput `pulumi:"grafanaInitialAdminPassword"` + // Specifies an initial Grafana admin username. + GrafanaInitialAdminUser pulumi.StringOutput `pulumi:"grafanaInitialAdminUser"` + // If true, anyone can access Grafana dashboards without logging in. + GrafanaPublicReadAccess pulumi.BoolOutput `pulumi:"grafanaPublicReadAccess"` + // Specifies Grafana URL. + GrafanaUrl pulumi.StringOutput `pulumi:"grafanaUrl"` + // The Observability instance ID. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Specifies if the instance can be updated. + IsUpdatable pulumi.BoolOutput `pulumi:"isUpdatable"` + JaegerTracesUrl pulumi.StringOutput `pulumi:"jaegerTracesUrl"` + JaegerUiUrl pulumi.StringOutput `pulumi:"jaegerUiUrl"` + // Specifies URL for pushing logs. + LogsPushUrl pulumi.StringOutput `pulumi:"logsPushUrl"` + // Specifies Logs URL. + LogsUrl pulumi.StringOutput `pulumi:"logsUrl"` + // Specifies URL for pushing metrics. + MetricsPushUrl pulumi.StringOutput `pulumi:"metricsPushUrl"` + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays pulumi.IntOutput `pulumi:"metricsRetentionDays"` + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling pulumi.IntOutput `pulumi:"metricsRetentionDays1hDownsampling"` + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling pulumi.IntOutput `pulumi:"metricsRetentionDays5mDownsampling"` + // Specifies metrics URL. + MetricsUrl pulumi.StringOutput `pulumi:"metricsUrl"` + // The name of the Observability instance. + Name pulumi.StringOutput `pulumi:"name"` + OtlpTracesUrl pulumi.StringOutput `pulumi:"otlpTracesUrl"` + // Additional parameters. + Parameters pulumi.StringMapOutput `pulumi:"parameters"` + // The Observability plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Specifies Targets URL. + TargetsUrl pulumi.StringOutput `pulumi:"targetsUrl"` + ZipkinSpansUrl pulumi.StringOutput `pulumi:"zipkinSpansUrl"` +} + +// NewObservabilityInstance registers a new resource with the given unique name, arguments, and options. +func NewObservabilityInstance(ctx *pulumi.Context, + name string, args *ObservabilityInstanceArgs, opts ...pulumi.ResourceOption) (*ObservabilityInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "grafanaInitialAdminPassword", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObservabilityInstance + err := ctx.RegisterResource("stackit:index/observabilityInstance:ObservabilityInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObservabilityInstance gets an existing ObservabilityInstance 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 GetObservabilityInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObservabilityInstanceState, opts ...pulumi.ResourceOption) (*ObservabilityInstance, error) { + var resource ObservabilityInstance + err := ctx.ReadResource("stackit:index/observabilityInstance:ObservabilityInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObservabilityInstance resources. +type observabilityInstanceState struct { + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls []string `pulumi:"acls"` + // Alert configuration for the instance. + AlertConfig *ObservabilityInstanceAlertConfig `pulumi:"alertConfig"` + // Specifies Alerting URL. + AlertingUrl *string `pulumi:"alertingUrl"` + // Specifies Observability instance dashboard URL. + DashboardUrl *string `pulumi:"dashboardUrl"` + // Specifies an initial Grafana admin password. + GrafanaInitialAdminPassword *string `pulumi:"grafanaInitialAdminPassword"` + // Specifies an initial Grafana admin username. + GrafanaInitialAdminUser *string `pulumi:"grafanaInitialAdminUser"` + // If true, anyone can access Grafana dashboards without logging in. + GrafanaPublicReadAccess *bool `pulumi:"grafanaPublicReadAccess"` + // Specifies Grafana URL. + GrafanaUrl *string `pulumi:"grafanaUrl"` + // The Observability instance ID. + InstanceId *string `pulumi:"instanceId"` + // Specifies if the instance can be updated. + IsUpdatable *bool `pulumi:"isUpdatable"` + JaegerTracesUrl *string `pulumi:"jaegerTracesUrl"` + JaegerUiUrl *string `pulumi:"jaegerUiUrl"` + // Specifies URL for pushing logs. + LogsPushUrl *string `pulumi:"logsPushUrl"` + // Specifies Logs URL. + LogsUrl *string `pulumi:"logsUrl"` + // Specifies URL for pushing metrics. + MetricsPushUrl *string `pulumi:"metricsPushUrl"` + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays *int `pulumi:"metricsRetentionDays"` + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling *int `pulumi:"metricsRetentionDays1hDownsampling"` + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling *int `pulumi:"metricsRetentionDays5mDownsampling"` + // Specifies metrics URL. + MetricsUrl *string `pulumi:"metricsUrl"` + // The name of the Observability instance. + Name *string `pulumi:"name"` + OtlpTracesUrl *string `pulumi:"otlpTracesUrl"` + // Additional parameters. + Parameters map[string]string `pulumi:"parameters"` + // The Observability plan ID. + PlanId *string `pulumi:"planId"` + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // Specifies Targets URL. + TargetsUrl *string `pulumi:"targetsUrl"` + ZipkinSpansUrl *string `pulumi:"zipkinSpansUrl"` +} + +type ObservabilityInstanceState struct { + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls pulumi.StringArrayInput + // Alert configuration for the instance. + AlertConfig ObservabilityInstanceAlertConfigPtrInput + // Specifies Alerting URL. + AlertingUrl pulumi.StringPtrInput + // Specifies Observability instance dashboard URL. + DashboardUrl pulumi.StringPtrInput + // Specifies an initial Grafana admin password. + GrafanaInitialAdminPassword pulumi.StringPtrInput + // Specifies an initial Grafana admin username. + GrafanaInitialAdminUser pulumi.StringPtrInput + // If true, anyone can access Grafana dashboards without logging in. + GrafanaPublicReadAccess pulumi.BoolPtrInput + // Specifies Grafana URL. + GrafanaUrl pulumi.StringPtrInput + // The Observability instance ID. + InstanceId pulumi.StringPtrInput + // Specifies if the instance can be updated. + IsUpdatable pulumi.BoolPtrInput + JaegerTracesUrl pulumi.StringPtrInput + JaegerUiUrl pulumi.StringPtrInput + // Specifies URL for pushing logs. + LogsPushUrl pulumi.StringPtrInput + // Specifies Logs URL. + LogsUrl pulumi.StringPtrInput + // Specifies URL for pushing metrics. + MetricsPushUrl pulumi.StringPtrInput + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays pulumi.IntPtrInput + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling pulumi.IntPtrInput + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling pulumi.IntPtrInput + // Specifies metrics URL. + MetricsUrl pulumi.StringPtrInput + // The name of the Observability instance. + Name pulumi.StringPtrInput + OtlpTracesUrl pulumi.StringPtrInput + // Additional parameters. + Parameters pulumi.StringMapInput + // The Observability plan ID. + PlanId pulumi.StringPtrInput + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // Specifies Targets URL. + TargetsUrl pulumi.StringPtrInput + ZipkinSpansUrl pulumi.StringPtrInput +} + +func (ObservabilityInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityInstanceState)(nil)).Elem() +} + +type observabilityInstanceArgs struct { + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls []string `pulumi:"acls"` + // Alert configuration for the instance. + AlertConfig *ObservabilityInstanceAlertConfig `pulumi:"alertConfig"` + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays *int `pulumi:"metricsRetentionDays"` + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling *int `pulumi:"metricsRetentionDays1hDownsampling"` + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling *int `pulumi:"metricsRetentionDays5mDownsampling"` + // The name of the Observability instance. + Name *string `pulumi:"name"` + // Additional parameters. + Parameters map[string]string `pulumi:"parameters"` + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a ObservabilityInstance resource. +type ObservabilityInstanceArgs struct { + // The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + Acls pulumi.StringArrayInput + // Alert configuration for the instance. + AlertConfig ObservabilityInstanceAlertConfigPtrInput + // Specifies for how many days the raw metrics are kept. + MetricsRetentionDays pulumi.IntPtrInput + // Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + MetricsRetentionDays1hDownsampling pulumi.IntPtrInput + // Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + MetricsRetentionDays5mDownsampling pulumi.IntPtrInput + // The name of the Observability instance. + Name pulumi.StringPtrInput + // Additional parameters. + Parameters pulumi.StringMapInput + // Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (ObservabilityInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityInstanceArgs)(nil)).Elem() +} + +type ObservabilityInstanceInput interface { + pulumi.Input + + ToObservabilityInstanceOutput() ObservabilityInstanceOutput + ToObservabilityInstanceOutputWithContext(ctx context.Context) ObservabilityInstanceOutput +} + +func (*ObservabilityInstance) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstance)(nil)).Elem() +} + +func (i *ObservabilityInstance) ToObservabilityInstanceOutput() ObservabilityInstanceOutput { + return i.ToObservabilityInstanceOutputWithContext(context.Background()) +} + +func (i *ObservabilityInstance) ToObservabilityInstanceOutputWithContext(ctx context.Context) ObservabilityInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceOutput) +} + +// ObservabilityInstanceArrayInput is an input type that accepts ObservabilityInstanceArray and ObservabilityInstanceArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceArrayInput` via: +// +// ObservabilityInstanceArray{ ObservabilityInstanceArgs{...} } +type ObservabilityInstanceArrayInput interface { + pulumi.Input + + ToObservabilityInstanceArrayOutput() ObservabilityInstanceArrayOutput + ToObservabilityInstanceArrayOutputWithContext(context.Context) ObservabilityInstanceArrayOutput +} + +type ObservabilityInstanceArray []ObservabilityInstanceInput + +func (ObservabilityInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityInstance)(nil)).Elem() +} + +func (i ObservabilityInstanceArray) ToObservabilityInstanceArrayOutput() ObservabilityInstanceArrayOutput { + return i.ToObservabilityInstanceArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceArray) ToObservabilityInstanceArrayOutputWithContext(ctx context.Context) ObservabilityInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceArrayOutput) +} + +// ObservabilityInstanceMapInput is an input type that accepts ObservabilityInstanceMap and ObservabilityInstanceMapOutput values. +// You can construct a concrete instance of `ObservabilityInstanceMapInput` via: +// +// ObservabilityInstanceMap{ "key": ObservabilityInstanceArgs{...} } +type ObservabilityInstanceMapInput interface { + pulumi.Input + + ToObservabilityInstanceMapOutput() ObservabilityInstanceMapOutput + ToObservabilityInstanceMapOutputWithContext(context.Context) ObservabilityInstanceMapOutput +} + +type ObservabilityInstanceMap map[string]ObservabilityInstanceInput + +func (ObservabilityInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityInstance)(nil)).Elem() +} + +func (i ObservabilityInstanceMap) ToObservabilityInstanceMapOutput() ObservabilityInstanceMapOutput { + return i.ToObservabilityInstanceMapOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceMap) ToObservabilityInstanceMapOutputWithContext(ctx context.Context) ObservabilityInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceMapOutput) +} + +type ObservabilityInstanceOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstance)(nil)).Elem() +} + +func (o ObservabilityInstanceOutput) ToObservabilityInstanceOutput() ObservabilityInstanceOutput { + return o +} + +func (o ObservabilityInstanceOutput) ToObservabilityInstanceOutputWithContext(ctx context.Context) ObservabilityInstanceOutput { + return o +} + +// The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. +func (o ObservabilityInstanceOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringArrayOutput { return v.Acls }).(pulumi.StringArrayOutput) +} + +// Alert configuration for the instance. +func (o ObservabilityInstanceOutput) AlertConfig() ObservabilityInstanceAlertConfigPtrOutput { + return o.ApplyT(func(v *ObservabilityInstance) ObservabilityInstanceAlertConfigPtrOutput { return v.AlertConfig }).(ObservabilityInstanceAlertConfigPtrOutput) +} + +// Specifies Alerting URL. +func (o ObservabilityInstanceOutput) AlertingUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.AlertingUrl }).(pulumi.StringOutput) +} + +// Specifies Observability instance dashboard URL. +func (o ObservabilityInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +// Specifies an initial Grafana admin password. +func (o ObservabilityInstanceOutput) GrafanaInitialAdminPassword() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.GrafanaInitialAdminPassword }).(pulumi.StringOutput) +} + +// Specifies an initial Grafana admin username. +func (o ObservabilityInstanceOutput) GrafanaInitialAdminUser() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.GrafanaInitialAdminUser }).(pulumi.StringOutput) +} + +// If true, anyone can access Grafana dashboards without logging in. +func (o ObservabilityInstanceOutput) GrafanaPublicReadAccess() pulumi.BoolOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.BoolOutput { return v.GrafanaPublicReadAccess }).(pulumi.BoolOutput) +} + +// Specifies Grafana URL. +func (o ObservabilityInstanceOutput) GrafanaUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.GrafanaUrl }).(pulumi.StringOutput) +} + +// The Observability instance ID. +func (o ObservabilityInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies if the instance can be updated. +func (o ObservabilityInstanceOutput) IsUpdatable() pulumi.BoolOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.BoolOutput { return v.IsUpdatable }).(pulumi.BoolOutput) +} + +func (o ObservabilityInstanceOutput) JaegerTracesUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.JaegerTracesUrl }).(pulumi.StringOutput) +} + +func (o ObservabilityInstanceOutput) JaegerUiUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.JaegerUiUrl }).(pulumi.StringOutput) +} + +// Specifies URL for pushing logs. +func (o ObservabilityInstanceOutput) LogsPushUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.LogsPushUrl }).(pulumi.StringOutput) +} + +// Specifies Logs URL. +func (o ObservabilityInstanceOutput) LogsUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.LogsUrl }).(pulumi.StringOutput) +} + +// Specifies URL for pushing metrics. +func (o ObservabilityInstanceOutput) MetricsPushUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.MetricsPushUrl }).(pulumi.StringOutput) +} + +// Specifies for how many days the raw metrics are kept. +func (o ObservabilityInstanceOutput) MetricsRetentionDays() pulumi.IntOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.IntOutput { return v.MetricsRetentionDays }).(pulumi.IntOutput) +} + +// Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). +func (o ObservabilityInstanceOutput) MetricsRetentionDays1hDownsampling() pulumi.IntOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.IntOutput { return v.MetricsRetentionDays1hDownsampling }).(pulumi.IntOutput) +} + +// Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). +func (o ObservabilityInstanceOutput) MetricsRetentionDays5mDownsampling() pulumi.IntOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.IntOutput { return v.MetricsRetentionDays5mDownsampling }).(pulumi.IntOutput) +} + +// Specifies metrics URL. +func (o ObservabilityInstanceOutput) MetricsUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.MetricsUrl }).(pulumi.StringOutput) +} + +// The name of the Observability instance. +func (o ObservabilityInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o ObservabilityInstanceOutput) OtlpTracesUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.OtlpTracesUrl }).(pulumi.StringOutput) +} + +// Additional parameters. +func (o ObservabilityInstanceOutput) Parameters() pulumi.StringMapOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringMapOutput { return v.Parameters }).(pulumi.StringMapOutput) +} + +// The Observability plan ID. +func (o ObservabilityInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. +func (o ObservabilityInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o ObservabilityInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Specifies Targets URL. +func (o ObservabilityInstanceOutput) TargetsUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.TargetsUrl }).(pulumi.StringOutput) +} + +func (o ObservabilityInstanceOutput) ZipkinSpansUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityInstance) pulumi.StringOutput { return v.ZipkinSpansUrl }).(pulumi.StringOutput) +} + +type ObservabilityInstanceArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityInstance)(nil)).Elem() +} + +func (o ObservabilityInstanceArrayOutput) ToObservabilityInstanceArrayOutput() ObservabilityInstanceArrayOutput { + return o +} + +func (o ObservabilityInstanceArrayOutput) ToObservabilityInstanceArrayOutputWithContext(ctx context.Context) ObservabilityInstanceArrayOutput { + return o +} + +func (o ObservabilityInstanceArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObservabilityInstance { + return vs[0].([]*ObservabilityInstance)[vs[1].(int)] + }).(ObservabilityInstanceOutput) +} + +type ObservabilityInstanceMapOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityInstance)(nil)).Elem() +} + +func (o ObservabilityInstanceMapOutput) ToObservabilityInstanceMapOutput() ObservabilityInstanceMapOutput { + return o +} + +func (o ObservabilityInstanceMapOutput) ToObservabilityInstanceMapOutputWithContext(ctx context.Context) ObservabilityInstanceMapOutput { + return o +} + +func (o ObservabilityInstanceMapOutput) MapIndex(k pulumi.StringInput) ObservabilityInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObservabilityInstance { + return vs[0].(map[string]*ObservabilityInstance)[vs[1].(string)] + }).(ObservabilityInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceInput)(nil)).Elem(), &ObservabilityInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceArrayInput)(nil)).Elem(), ObservabilityInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceMapInput)(nil)).Elem(), ObservabilityInstanceMap{}) + pulumi.RegisterOutputType(ObservabilityInstanceOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/observabilityLogalertgroup.go b/sdk/go/stackit/observabilityLogalertgroup.go new file mode 100644 index 0000000..9096326 --- /dev/null +++ b/sdk/go/stackit/observabilityLogalertgroup.go @@ -0,0 +1,287 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObservabilityLogalertgroup struct { + pulumi.CustomResourceState + + // Observability instance ID to which the log alert group is associated. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringOutput `pulumi:"interval"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Rules for the log alert group + Rules ObservabilityLogalertgroupRuleArrayOutput `pulumi:"rules"` +} + +// NewObservabilityLogalertgroup registers a new resource with the given unique name, arguments, and options. +func NewObservabilityLogalertgroup(ctx *pulumi.Context, + name string, args *ObservabilityLogalertgroupArgs, opts ...pulumi.ResourceOption) (*ObservabilityLogalertgroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Rules == nil { + return nil, errors.New("invalid value for required argument 'Rules'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObservabilityLogalertgroup + err := ctx.RegisterResource("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObservabilityLogalertgroup gets an existing ObservabilityLogalertgroup 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 GetObservabilityLogalertgroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObservabilityLogalertgroupState, opts ...pulumi.ResourceOption) (*ObservabilityLogalertgroup, error) { + var resource ObservabilityLogalertgroup + err := ctx.ReadResource("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObservabilityLogalertgroup resources. +type observabilityLogalertgroupState struct { + // Observability instance ID to which the log alert group is associated. + InstanceId *string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval *string `pulumi:"interval"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId *string `pulumi:"projectId"` + // Rules for the log alert group + Rules []ObservabilityLogalertgroupRule `pulumi:"rules"` +} + +type ObservabilityLogalertgroupState struct { + // Observability instance ID to which the log alert group is associated. + InstanceId pulumi.StringPtrInput + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringPtrInput + // The name of the log alert group. Is the identifier and must be unique in the group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the log alert group is associated. + ProjectId pulumi.StringPtrInput + // Rules for the log alert group + Rules ObservabilityLogalertgroupRuleArrayInput +} + +func (ObservabilityLogalertgroupState) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityLogalertgroupState)(nil)).Elem() +} + +type observabilityLogalertgroupArgs struct { + // Observability instance ID to which the log alert group is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval *string `pulumi:"interval"` + // The name of the log alert group. Is the identifier and must be unique in the group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the log alert group is associated. + ProjectId string `pulumi:"projectId"` + // Rules for the log alert group + Rules []ObservabilityLogalertgroupRule `pulumi:"rules"` +} + +// The set of arguments for constructing a ObservabilityLogalertgroup resource. +type ObservabilityLogalertgroupArgs struct { + // Observability instance ID to which the log alert group is associated. + InstanceId pulumi.StringInput + // Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + Interval pulumi.StringPtrInput + // The name of the log alert group. Is the identifier and must be unique in the group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the log alert group is associated. + ProjectId pulumi.StringInput + // Rules for the log alert group + Rules ObservabilityLogalertgroupRuleArrayInput +} + +func (ObservabilityLogalertgroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityLogalertgroupArgs)(nil)).Elem() +} + +type ObservabilityLogalertgroupInput interface { + pulumi.Input + + ToObservabilityLogalertgroupOutput() ObservabilityLogalertgroupOutput + ToObservabilityLogalertgroupOutputWithContext(ctx context.Context) ObservabilityLogalertgroupOutput +} + +func (*ObservabilityLogalertgroup) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityLogalertgroup)(nil)).Elem() +} + +func (i *ObservabilityLogalertgroup) ToObservabilityLogalertgroupOutput() ObservabilityLogalertgroupOutput { + return i.ToObservabilityLogalertgroupOutputWithContext(context.Background()) +} + +func (i *ObservabilityLogalertgroup) ToObservabilityLogalertgroupOutputWithContext(ctx context.Context) ObservabilityLogalertgroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityLogalertgroupOutput) +} + +// ObservabilityLogalertgroupArrayInput is an input type that accepts ObservabilityLogalertgroupArray and ObservabilityLogalertgroupArrayOutput values. +// You can construct a concrete instance of `ObservabilityLogalertgroupArrayInput` via: +// +// ObservabilityLogalertgroupArray{ ObservabilityLogalertgroupArgs{...} } +type ObservabilityLogalertgroupArrayInput interface { + pulumi.Input + + ToObservabilityLogalertgroupArrayOutput() ObservabilityLogalertgroupArrayOutput + ToObservabilityLogalertgroupArrayOutputWithContext(context.Context) ObservabilityLogalertgroupArrayOutput +} + +type ObservabilityLogalertgroupArray []ObservabilityLogalertgroupInput + +func (ObservabilityLogalertgroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityLogalertgroup)(nil)).Elem() +} + +func (i ObservabilityLogalertgroupArray) ToObservabilityLogalertgroupArrayOutput() ObservabilityLogalertgroupArrayOutput { + return i.ToObservabilityLogalertgroupArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityLogalertgroupArray) ToObservabilityLogalertgroupArrayOutputWithContext(ctx context.Context) ObservabilityLogalertgroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityLogalertgroupArrayOutput) +} + +// ObservabilityLogalertgroupMapInput is an input type that accepts ObservabilityLogalertgroupMap and ObservabilityLogalertgroupMapOutput values. +// You can construct a concrete instance of `ObservabilityLogalertgroupMapInput` via: +// +// ObservabilityLogalertgroupMap{ "key": ObservabilityLogalertgroupArgs{...} } +type ObservabilityLogalertgroupMapInput interface { + pulumi.Input + + ToObservabilityLogalertgroupMapOutput() ObservabilityLogalertgroupMapOutput + ToObservabilityLogalertgroupMapOutputWithContext(context.Context) ObservabilityLogalertgroupMapOutput +} + +type ObservabilityLogalertgroupMap map[string]ObservabilityLogalertgroupInput + +func (ObservabilityLogalertgroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityLogalertgroup)(nil)).Elem() +} + +func (i ObservabilityLogalertgroupMap) ToObservabilityLogalertgroupMapOutput() ObservabilityLogalertgroupMapOutput { + return i.ToObservabilityLogalertgroupMapOutputWithContext(context.Background()) +} + +func (i ObservabilityLogalertgroupMap) ToObservabilityLogalertgroupMapOutputWithContext(ctx context.Context) ObservabilityLogalertgroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityLogalertgroupMapOutput) +} + +type ObservabilityLogalertgroupOutput struct{ *pulumi.OutputState } + +func (ObservabilityLogalertgroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityLogalertgroup)(nil)).Elem() +} + +func (o ObservabilityLogalertgroupOutput) ToObservabilityLogalertgroupOutput() ObservabilityLogalertgroupOutput { + return o +} + +func (o ObservabilityLogalertgroupOutput) ToObservabilityLogalertgroupOutputWithContext(ctx context.Context) ObservabilityLogalertgroupOutput { + return o +} + +// Observability instance ID to which the log alert group is associated. +func (o ObservabilityLogalertgroupOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityLogalertgroup) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. +func (o ObservabilityLogalertgroupOutput) Interval() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityLogalertgroup) pulumi.StringOutput { return v.Interval }).(pulumi.StringOutput) +} + +// The name of the log alert group. Is the identifier and must be unique in the group. +func (o ObservabilityLogalertgroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityLogalertgroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the log alert group is associated. +func (o ObservabilityLogalertgroupOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityLogalertgroup) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Rules for the log alert group +func (o ObservabilityLogalertgroupOutput) Rules() ObservabilityLogalertgroupRuleArrayOutput { + return o.ApplyT(func(v *ObservabilityLogalertgroup) ObservabilityLogalertgroupRuleArrayOutput { return v.Rules }).(ObservabilityLogalertgroupRuleArrayOutput) +} + +type ObservabilityLogalertgroupArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityLogalertgroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityLogalertgroup)(nil)).Elem() +} + +func (o ObservabilityLogalertgroupArrayOutput) ToObservabilityLogalertgroupArrayOutput() ObservabilityLogalertgroupArrayOutput { + return o +} + +func (o ObservabilityLogalertgroupArrayOutput) ToObservabilityLogalertgroupArrayOutputWithContext(ctx context.Context) ObservabilityLogalertgroupArrayOutput { + return o +} + +func (o ObservabilityLogalertgroupArrayOutput) Index(i pulumi.IntInput) ObservabilityLogalertgroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObservabilityLogalertgroup { + return vs[0].([]*ObservabilityLogalertgroup)[vs[1].(int)] + }).(ObservabilityLogalertgroupOutput) +} + +type ObservabilityLogalertgroupMapOutput struct{ *pulumi.OutputState } + +func (ObservabilityLogalertgroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityLogalertgroup)(nil)).Elem() +} + +func (o ObservabilityLogalertgroupMapOutput) ToObservabilityLogalertgroupMapOutput() ObservabilityLogalertgroupMapOutput { + return o +} + +func (o ObservabilityLogalertgroupMapOutput) ToObservabilityLogalertgroupMapOutputWithContext(ctx context.Context) ObservabilityLogalertgroupMapOutput { + return o +} + +func (o ObservabilityLogalertgroupMapOutput) MapIndex(k pulumi.StringInput) ObservabilityLogalertgroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObservabilityLogalertgroup { + return vs[0].(map[string]*ObservabilityLogalertgroup)[vs[1].(string)] + }).(ObservabilityLogalertgroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityLogalertgroupInput)(nil)).Elem(), &ObservabilityLogalertgroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityLogalertgroupArrayInput)(nil)).Elem(), ObservabilityLogalertgroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityLogalertgroupMapInput)(nil)).Elem(), ObservabilityLogalertgroupMap{}) + pulumi.RegisterOutputType(ObservabilityLogalertgroupOutput{}) + pulumi.RegisterOutputType(ObservabilityLogalertgroupArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityLogalertgroupMapOutput{}) +} diff --git a/sdk/go/stackit/observabilityScrapeconfig.go b/sdk/go/stackit/observabilityScrapeconfig.go new file mode 100644 index 0000000..6307fa9 --- /dev/null +++ b/sdk/go/stackit/observabilityScrapeconfig.go @@ -0,0 +1,380 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Observability scrape config resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ObservabilityScrapeconfig struct { + pulumi.CustomResourceState + + // A basic authentication block. + BasicAuth ObservabilityScrapeconfigBasicAuthOutput `pulumi:"basicAuth"` + // Observability instance ID to which the scraping job is associated. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Specifies the job scraping url path. E.g. `/metrics`. + MetricsPath pulumi.StringOutput `pulumi:"metricsPath"` + // Specifies the name of the scraping job. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // A SAML2 configuration block. + Saml2 ObservabilityScrapeconfigSaml2Output `pulumi:"saml2"` + // Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + SampleLimit pulumi.IntOutput `pulumi:"sampleLimit"` + // Specifies the http scheme. Defaults to `https`. + Scheme pulumi.StringOutput `pulumi:"scheme"` + // Specifies the scrape interval as duration string. Defaults to `5m`. + ScrapeInterval pulumi.StringOutput `pulumi:"scrapeInterval"` + // Specifies the scrape timeout as duration string. Defaults to `2m`. + ScrapeTimeout pulumi.StringOutput `pulumi:"scrapeTimeout"` + // The targets list (specified by the static config). + Targets ObservabilityScrapeconfigTargetArrayOutput `pulumi:"targets"` +} + +// NewObservabilityScrapeconfig registers a new resource with the given unique name, arguments, and options. +func NewObservabilityScrapeconfig(ctx *pulumi.Context, + name string, args *ObservabilityScrapeconfigArgs, opts ...pulumi.ResourceOption) (*ObservabilityScrapeconfig, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.MetricsPath == nil { + return nil, errors.New("invalid value for required argument 'MetricsPath'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Targets == nil { + return nil, errors.New("invalid value for required argument 'Targets'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ObservabilityScrapeconfig + err := ctx.RegisterResource("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetObservabilityScrapeconfig gets an existing ObservabilityScrapeconfig 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 GetObservabilityScrapeconfig(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ObservabilityScrapeconfigState, opts ...pulumi.ResourceOption) (*ObservabilityScrapeconfig, error) { + var resource ObservabilityScrapeconfig + err := ctx.ReadResource("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ObservabilityScrapeconfig resources. +type observabilityScrapeconfigState struct { + // A basic authentication block. + BasicAuth *ObservabilityScrapeconfigBasicAuth `pulumi:"basicAuth"` + // Observability instance ID to which the scraping job is associated. + InstanceId *string `pulumi:"instanceId"` + // Specifies the job scraping url path. E.g. `/metrics`. + MetricsPath *string `pulumi:"metricsPath"` + // Specifies the name of the scraping job. + Name *string `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId *string `pulumi:"projectId"` + // A SAML2 configuration block. + Saml2 *ObservabilityScrapeconfigSaml2 `pulumi:"saml2"` + // Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + SampleLimit *int `pulumi:"sampleLimit"` + // Specifies the http scheme. Defaults to `https`. + Scheme *string `pulumi:"scheme"` + // Specifies the scrape interval as duration string. Defaults to `5m`. + ScrapeInterval *string `pulumi:"scrapeInterval"` + // Specifies the scrape timeout as duration string. Defaults to `2m`. + ScrapeTimeout *string `pulumi:"scrapeTimeout"` + // The targets list (specified by the static config). + Targets []ObservabilityScrapeconfigTarget `pulumi:"targets"` +} + +type ObservabilityScrapeconfigState struct { + // A basic authentication block. + BasicAuth ObservabilityScrapeconfigBasicAuthPtrInput + // Observability instance ID to which the scraping job is associated. + InstanceId pulumi.StringPtrInput + // Specifies the job scraping url path. E.g. `/metrics`. + MetricsPath pulumi.StringPtrInput + // Specifies the name of the scraping job. + Name pulumi.StringPtrInput + // STACKIT project ID to which the scraping job is associated. + ProjectId pulumi.StringPtrInput + // A SAML2 configuration block. + Saml2 ObservabilityScrapeconfigSaml2PtrInput + // Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + SampleLimit pulumi.IntPtrInput + // Specifies the http scheme. Defaults to `https`. + Scheme pulumi.StringPtrInput + // Specifies the scrape interval as duration string. Defaults to `5m`. + ScrapeInterval pulumi.StringPtrInput + // Specifies the scrape timeout as duration string. Defaults to `2m`. + ScrapeTimeout pulumi.StringPtrInput + // The targets list (specified by the static config). + Targets ObservabilityScrapeconfigTargetArrayInput +} + +func (ObservabilityScrapeconfigState) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityScrapeconfigState)(nil)).Elem() +} + +type observabilityScrapeconfigArgs struct { + // A basic authentication block. + BasicAuth *ObservabilityScrapeconfigBasicAuth `pulumi:"basicAuth"` + // Observability instance ID to which the scraping job is associated. + InstanceId string `pulumi:"instanceId"` + // Specifies the job scraping url path. E.g. `/metrics`. + MetricsPath string `pulumi:"metricsPath"` + // Specifies the name of the scraping job. + Name *string `pulumi:"name"` + // STACKIT project ID to which the scraping job is associated. + ProjectId string `pulumi:"projectId"` + // A SAML2 configuration block. + Saml2 *ObservabilityScrapeconfigSaml2 `pulumi:"saml2"` + // Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + SampleLimit *int `pulumi:"sampleLimit"` + // Specifies the http scheme. Defaults to `https`. + Scheme *string `pulumi:"scheme"` + // Specifies the scrape interval as duration string. Defaults to `5m`. + ScrapeInterval *string `pulumi:"scrapeInterval"` + // Specifies the scrape timeout as duration string. Defaults to `2m`. + ScrapeTimeout *string `pulumi:"scrapeTimeout"` + // The targets list (specified by the static config). + Targets []ObservabilityScrapeconfigTarget `pulumi:"targets"` +} + +// The set of arguments for constructing a ObservabilityScrapeconfig resource. +type ObservabilityScrapeconfigArgs struct { + // A basic authentication block. + BasicAuth ObservabilityScrapeconfigBasicAuthPtrInput + // Observability instance ID to which the scraping job is associated. + InstanceId pulumi.StringInput + // Specifies the job scraping url path. E.g. `/metrics`. + MetricsPath pulumi.StringInput + // Specifies the name of the scraping job. + Name pulumi.StringPtrInput + // STACKIT project ID to which the scraping job is associated. + ProjectId pulumi.StringInput + // A SAML2 configuration block. + Saml2 ObservabilityScrapeconfigSaml2PtrInput + // Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + SampleLimit pulumi.IntPtrInput + // Specifies the http scheme. Defaults to `https`. + Scheme pulumi.StringPtrInput + // Specifies the scrape interval as duration string. Defaults to `5m`. + ScrapeInterval pulumi.StringPtrInput + // Specifies the scrape timeout as duration string. Defaults to `2m`. + ScrapeTimeout pulumi.StringPtrInput + // The targets list (specified by the static config). + Targets ObservabilityScrapeconfigTargetArrayInput +} + +func (ObservabilityScrapeconfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*observabilityScrapeconfigArgs)(nil)).Elem() +} + +type ObservabilityScrapeconfigInput interface { + pulumi.Input + + ToObservabilityScrapeconfigOutput() ObservabilityScrapeconfigOutput + ToObservabilityScrapeconfigOutputWithContext(ctx context.Context) ObservabilityScrapeconfigOutput +} + +func (*ObservabilityScrapeconfig) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfig)(nil)).Elem() +} + +func (i *ObservabilityScrapeconfig) ToObservabilityScrapeconfigOutput() ObservabilityScrapeconfigOutput { + return i.ToObservabilityScrapeconfigOutputWithContext(context.Background()) +} + +func (i *ObservabilityScrapeconfig) ToObservabilityScrapeconfigOutputWithContext(ctx context.Context) ObservabilityScrapeconfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigOutput) +} + +// ObservabilityScrapeconfigArrayInput is an input type that accepts ObservabilityScrapeconfigArray and ObservabilityScrapeconfigArrayOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigArrayInput` via: +// +// ObservabilityScrapeconfigArray{ ObservabilityScrapeconfigArgs{...} } +type ObservabilityScrapeconfigArrayInput interface { + pulumi.Input + + ToObservabilityScrapeconfigArrayOutput() ObservabilityScrapeconfigArrayOutput + ToObservabilityScrapeconfigArrayOutputWithContext(context.Context) ObservabilityScrapeconfigArrayOutput +} + +type ObservabilityScrapeconfigArray []ObservabilityScrapeconfigInput + +func (ObservabilityScrapeconfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityScrapeconfig)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigArray) ToObservabilityScrapeconfigArrayOutput() ObservabilityScrapeconfigArrayOutput { + return i.ToObservabilityScrapeconfigArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigArray) ToObservabilityScrapeconfigArrayOutputWithContext(ctx context.Context) ObservabilityScrapeconfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigArrayOutput) +} + +// ObservabilityScrapeconfigMapInput is an input type that accepts ObservabilityScrapeconfigMap and ObservabilityScrapeconfigMapOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigMapInput` via: +// +// ObservabilityScrapeconfigMap{ "key": ObservabilityScrapeconfigArgs{...} } +type ObservabilityScrapeconfigMapInput interface { + pulumi.Input + + ToObservabilityScrapeconfigMapOutput() ObservabilityScrapeconfigMapOutput + ToObservabilityScrapeconfigMapOutputWithContext(context.Context) ObservabilityScrapeconfigMapOutput +} + +type ObservabilityScrapeconfigMap map[string]ObservabilityScrapeconfigInput + +func (ObservabilityScrapeconfigMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityScrapeconfig)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigMap) ToObservabilityScrapeconfigMapOutput() ObservabilityScrapeconfigMapOutput { + return i.ToObservabilityScrapeconfigMapOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigMap) ToObservabilityScrapeconfigMapOutputWithContext(ctx context.Context) ObservabilityScrapeconfigMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigMapOutput) +} + +type ObservabilityScrapeconfigOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfig)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigOutput) ToObservabilityScrapeconfigOutput() ObservabilityScrapeconfigOutput { + return o +} + +func (o ObservabilityScrapeconfigOutput) ToObservabilityScrapeconfigOutputWithContext(ctx context.Context) ObservabilityScrapeconfigOutput { + return o +} + +// A basic authentication block. +func (o ObservabilityScrapeconfigOutput) BasicAuth() ObservabilityScrapeconfigBasicAuthOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) ObservabilityScrapeconfigBasicAuthOutput { return v.BasicAuth }).(ObservabilityScrapeconfigBasicAuthOutput) +} + +// Observability instance ID to which the scraping job is associated. +func (o ObservabilityScrapeconfigOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Specifies the job scraping url path. E.g. `/metrics`. +func (o ObservabilityScrapeconfigOutput) MetricsPath() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.MetricsPath }).(pulumi.StringOutput) +} + +// Specifies the name of the scraping job. +func (o ObservabilityScrapeconfigOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the scraping job is associated. +func (o ObservabilityScrapeconfigOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// A SAML2 configuration block. +func (o ObservabilityScrapeconfigOutput) Saml2() ObservabilityScrapeconfigSaml2Output { + return o.ApplyT(func(v *ObservabilityScrapeconfig) ObservabilityScrapeconfigSaml2Output { return v.Saml2 }).(ObservabilityScrapeconfigSaml2Output) +} + +// Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. +func (o ObservabilityScrapeconfigOutput) SampleLimit() pulumi.IntOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.IntOutput { return v.SampleLimit }).(pulumi.IntOutput) +} + +// Specifies the http scheme. Defaults to `https`. +func (o ObservabilityScrapeconfigOutput) Scheme() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.Scheme }).(pulumi.StringOutput) +} + +// Specifies the scrape interval as duration string. Defaults to `5m`. +func (o ObservabilityScrapeconfigOutput) ScrapeInterval() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.ScrapeInterval }).(pulumi.StringOutput) +} + +// Specifies the scrape timeout as duration string. Defaults to `2m`. +func (o ObservabilityScrapeconfigOutput) ScrapeTimeout() pulumi.StringOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) pulumi.StringOutput { return v.ScrapeTimeout }).(pulumi.StringOutput) +} + +// The targets list (specified by the static config). +func (o ObservabilityScrapeconfigOutput) Targets() ObservabilityScrapeconfigTargetArrayOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfig) ObservabilityScrapeconfigTargetArrayOutput { return v.Targets }).(ObservabilityScrapeconfigTargetArrayOutput) +} + +type ObservabilityScrapeconfigArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ObservabilityScrapeconfig)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigArrayOutput) ToObservabilityScrapeconfigArrayOutput() ObservabilityScrapeconfigArrayOutput { + return o +} + +func (o ObservabilityScrapeconfigArrayOutput) ToObservabilityScrapeconfigArrayOutputWithContext(ctx context.Context) ObservabilityScrapeconfigArrayOutput { + return o +} + +func (o ObservabilityScrapeconfigArrayOutput) Index(i pulumi.IntInput) ObservabilityScrapeconfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ObservabilityScrapeconfig { + return vs[0].([]*ObservabilityScrapeconfig)[vs[1].(int)] + }).(ObservabilityScrapeconfigOutput) +} + +type ObservabilityScrapeconfigMapOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ObservabilityScrapeconfig)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigMapOutput) ToObservabilityScrapeconfigMapOutput() ObservabilityScrapeconfigMapOutput { + return o +} + +func (o ObservabilityScrapeconfigMapOutput) ToObservabilityScrapeconfigMapOutputWithContext(ctx context.Context) ObservabilityScrapeconfigMapOutput { + return o +} + +func (o ObservabilityScrapeconfigMapOutput) MapIndex(k pulumi.StringInput) ObservabilityScrapeconfigOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ObservabilityScrapeconfig { + return vs[0].(map[string]*ObservabilityScrapeconfig)[vs[1].(string)] + }).(ObservabilityScrapeconfigOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigInput)(nil)).Elem(), &ObservabilityScrapeconfig{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigArrayInput)(nil)).Elem(), ObservabilityScrapeconfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigMapInput)(nil)).Elem(), ObservabilityScrapeconfigMap{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigMapOutput{}) +} diff --git a/sdk/go/stackit/opensearchCredential.go b/sdk/go/stackit/opensearchCredential.go new file mode 100644 index 0000000..e1036eb --- /dev/null +++ b/sdk/go/stackit/opensearchCredential.go @@ -0,0 +1,304 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// OpenSearch credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type OpensearchCredential struct { + pulumi.CustomResourceState + + // The credential's ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + Host pulumi.StringOutput `pulumi:"host"` + Hosts pulumi.StringArrayOutput `pulumi:"hosts"` + // ID of the OpenSearch instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Scheme pulumi.StringOutput `pulumi:"scheme"` + Uri pulumi.StringOutput `pulumi:"uri"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewOpensearchCredential registers a new resource with the given unique name, arguments, and options. +func NewOpensearchCredential(ctx *pulumi.Context, + name string, args *OpensearchCredentialArgs, opts ...pulumi.ResourceOption) (*OpensearchCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource OpensearchCredential + err := ctx.RegisterResource("stackit:index/opensearchCredential:OpensearchCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOpensearchCredential gets an existing OpensearchCredential 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 GetOpensearchCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OpensearchCredentialState, opts ...pulumi.ResourceOption) (*OpensearchCredential, error) { + var resource OpensearchCredential + err := ctx.ReadResource("stackit:index/opensearchCredential:OpensearchCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OpensearchCredential resources. +type opensearchCredentialState struct { + // The credential's ID. + CredentialId *string `pulumi:"credentialId"` + Host *string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + // ID of the OpenSearch instance. + InstanceId *string `pulumi:"instanceId"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Scheme *string `pulumi:"scheme"` + Uri *string `pulumi:"uri"` + Username *string `pulumi:"username"` +} + +type OpensearchCredentialState struct { + // The credential's ID. + CredentialId pulumi.StringPtrInput + Host pulumi.StringPtrInput + Hosts pulumi.StringArrayInput + // ID of the OpenSearch instance. + InstanceId pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Scheme pulumi.StringPtrInput + Uri pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (OpensearchCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*opensearchCredentialState)(nil)).Elem() +} + +type opensearchCredentialArgs struct { + // ID of the OpenSearch instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a OpensearchCredential resource. +type OpensearchCredentialArgs struct { + // ID of the OpenSearch instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (OpensearchCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*opensearchCredentialArgs)(nil)).Elem() +} + +type OpensearchCredentialInput interface { + pulumi.Input + + ToOpensearchCredentialOutput() OpensearchCredentialOutput + ToOpensearchCredentialOutputWithContext(ctx context.Context) OpensearchCredentialOutput +} + +func (*OpensearchCredential) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchCredential)(nil)).Elem() +} + +func (i *OpensearchCredential) ToOpensearchCredentialOutput() OpensearchCredentialOutput { + return i.ToOpensearchCredentialOutputWithContext(context.Background()) +} + +func (i *OpensearchCredential) ToOpensearchCredentialOutputWithContext(ctx context.Context) OpensearchCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchCredentialOutput) +} + +// OpensearchCredentialArrayInput is an input type that accepts OpensearchCredentialArray and OpensearchCredentialArrayOutput values. +// You can construct a concrete instance of `OpensearchCredentialArrayInput` via: +// +// OpensearchCredentialArray{ OpensearchCredentialArgs{...} } +type OpensearchCredentialArrayInput interface { + pulumi.Input + + ToOpensearchCredentialArrayOutput() OpensearchCredentialArrayOutput + ToOpensearchCredentialArrayOutputWithContext(context.Context) OpensearchCredentialArrayOutput +} + +type OpensearchCredentialArray []OpensearchCredentialInput + +func (OpensearchCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OpensearchCredential)(nil)).Elem() +} + +func (i OpensearchCredentialArray) ToOpensearchCredentialArrayOutput() OpensearchCredentialArrayOutput { + return i.ToOpensearchCredentialArrayOutputWithContext(context.Background()) +} + +func (i OpensearchCredentialArray) ToOpensearchCredentialArrayOutputWithContext(ctx context.Context) OpensearchCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchCredentialArrayOutput) +} + +// OpensearchCredentialMapInput is an input type that accepts OpensearchCredentialMap and OpensearchCredentialMapOutput values. +// You can construct a concrete instance of `OpensearchCredentialMapInput` via: +// +// OpensearchCredentialMap{ "key": OpensearchCredentialArgs{...} } +type OpensearchCredentialMapInput interface { + pulumi.Input + + ToOpensearchCredentialMapOutput() OpensearchCredentialMapOutput + ToOpensearchCredentialMapOutputWithContext(context.Context) OpensearchCredentialMapOutput +} + +type OpensearchCredentialMap map[string]OpensearchCredentialInput + +func (OpensearchCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OpensearchCredential)(nil)).Elem() +} + +func (i OpensearchCredentialMap) ToOpensearchCredentialMapOutput() OpensearchCredentialMapOutput { + return i.ToOpensearchCredentialMapOutputWithContext(context.Background()) +} + +func (i OpensearchCredentialMap) ToOpensearchCredentialMapOutputWithContext(ctx context.Context) OpensearchCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchCredentialMapOutput) +} + +type OpensearchCredentialOutput struct{ *pulumi.OutputState } + +func (OpensearchCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchCredential)(nil)).Elem() +} + +func (o OpensearchCredentialOutput) ToOpensearchCredentialOutput() OpensearchCredentialOutput { + return o +} + +func (o OpensearchCredentialOutput) ToOpensearchCredentialOutputWithContext(ctx context.Context) OpensearchCredentialOutput { + return o +} + +// The credential's ID. +func (o OpensearchCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringArrayOutput { return v.Hosts }).(pulumi.StringArrayOutput) +} + +// ID of the OpenSearch instance. +func (o OpensearchCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o OpensearchCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Scheme() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.Scheme }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +func (o OpensearchCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type OpensearchCredentialArrayOutput struct{ *pulumi.OutputState } + +func (OpensearchCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OpensearchCredential)(nil)).Elem() +} + +func (o OpensearchCredentialArrayOutput) ToOpensearchCredentialArrayOutput() OpensearchCredentialArrayOutput { + return o +} + +func (o OpensearchCredentialArrayOutput) ToOpensearchCredentialArrayOutputWithContext(ctx context.Context) OpensearchCredentialArrayOutput { + return o +} + +func (o OpensearchCredentialArrayOutput) Index(i pulumi.IntInput) OpensearchCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OpensearchCredential { + return vs[0].([]*OpensearchCredential)[vs[1].(int)] + }).(OpensearchCredentialOutput) +} + +type OpensearchCredentialMapOutput struct{ *pulumi.OutputState } + +func (OpensearchCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OpensearchCredential)(nil)).Elem() +} + +func (o OpensearchCredentialMapOutput) ToOpensearchCredentialMapOutput() OpensearchCredentialMapOutput { + return o +} + +func (o OpensearchCredentialMapOutput) ToOpensearchCredentialMapOutputWithContext(ctx context.Context) OpensearchCredentialMapOutput { + return o +} + +func (o OpensearchCredentialMapOutput) MapIndex(k pulumi.StringInput) OpensearchCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OpensearchCredential { + return vs[0].(map[string]*OpensearchCredential)[vs[1].(string)] + }).(OpensearchCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchCredentialInput)(nil)).Elem(), &OpensearchCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchCredentialArrayInput)(nil)).Elem(), OpensearchCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchCredentialMapInput)(nil)).Elem(), OpensearchCredentialMap{}) + pulumi.RegisterOutputType(OpensearchCredentialOutput{}) + pulumi.RegisterOutputType(OpensearchCredentialArrayOutput{}) + pulumi.RegisterOutputType(OpensearchCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/opensearchInstance.go b/sdk/go/stackit/opensearchInstance.go new file mode 100644 index 0000000..3465398 --- /dev/null +++ b/sdk/go/stackit/opensearchInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// OpenSearch instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type OpensearchInstance struct { + pulumi.CustomResourceState + + CfGuid pulumi.StringOutput `pulumi:"cfGuid"` + CfOrganizationGuid pulumi.StringOutput `pulumi:"cfOrganizationGuid"` + CfSpaceGuid pulumi.StringOutput `pulumi:"cfSpaceGuid"` + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + ImageUrl pulumi.StringOutput `pulumi:"imageUrl"` + // ID of the OpenSearch instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Parameters OpensearchInstanceParametersOutput `pulumi:"parameters"` + // The selected plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // The selected plan name. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The service version. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewOpensearchInstance registers a new resource with the given unique name, arguments, and options. +func NewOpensearchInstance(ctx *pulumi.Context, + name string, args *OpensearchInstanceArgs, opts ...pulumi.ResourceOption) (*OpensearchInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OpensearchInstance + err := ctx.RegisterResource("stackit:index/opensearchInstance:OpensearchInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOpensearchInstance gets an existing OpensearchInstance 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 GetOpensearchInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OpensearchInstanceState, opts ...pulumi.ResourceOption) (*OpensearchInstance, error) { + var resource OpensearchInstance + err := ctx.ReadResource("stackit:index/opensearchInstance:OpensearchInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OpensearchInstance resources. +type opensearchInstanceState struct { + CfGuid *string `pulumi:"cfGuid"` + CfOrganizationGuid *string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid *string `pulumi:"cfSpaceGuid"` + DashboardUrl *string `pulumi:"dashboardUrl"` + ImageUrl *string `pulumi:"imageUrl"` + // ID of the OpenSearch instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Parameters *OpensearchInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId *string `pulumi:"planId"` + // The selected plan name. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The service version. + Version *string `pulumi:"version"` +} + +type OpensearchInstanceState struct { + CfGuid pulumi.StringPtrInput + CfOrganizationGuid pulumi.StringPtrInput + CfSpaceGuid pulumi.StringPtrInput + DashboardUrl pulumi.StringPtrInput + ImageUrl pulumi.StringPtrInput + // ID of the OpenSearch instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Parameters OpensearchInstanceParametersPtrInput + // The selected plan ID. + PlanId pulumi.StringPtrInput + // The selected plan name. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The service version. + Version pulumi.StringPtrInput +} + +func (OpensearchInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*opensearchInstanceState)(nil)).Elem() +} + +type opensearchInstanceArgs struct { + // Instance name. + Name *string `pulumi:"name"` + Parameters *OpensearchInstanceParameters `pulumi:"parameters"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a OpensearchInstance resource. +type OpensearchInstanceArgs struct { + // Instance name. + Name pulumi.StringPtrInput + Parameters OpensearchInstanceParametersPtrInput + // The selected plan name. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The service version. + Version pulumi.StringInput +} + +func (OpensearchInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*opensearchInstanceArgs)(nil)).Elem() +} + +type OpensearchInstanceInput interface { + pulumi.Input + + ToOpensearchInstanceOutput() OpensearchInstanceOutput + ToOpensearchInstanceOutputWithContext(ctx context.Context) OpensearchInstanceOutput +} + +func (*OpensearchInstance) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchInstance)(nil)).Elem() +} + +func (i *OpensearchInstance) ToOpensearchInstanceOutput() OpensearchInstanceOutput { + return i.ToOpensearchInstanceOutputWithContext(context.Background()) +} + +func (i *OpensearchInstance) ToOpensearchInstanceOutputWithContext(ctx context.Context) OpensearchInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceOutput) +} + +// OpensearchInstanceArrayInput is an input type that accepts OpensearchInstanceArray and OpensearchInstanceArrayOutput values. +// You can construct a concrete instance of `OpensearchInstanceArrayInput` via: +// +// OpensearchInstanceArray{ OpensearchInstanceArgs{...} } +type OpensearchInstanceArrayInput interface { + pulumi.Input + + ToOpensearchInstanceArrayOutput() OpensearchInstanceArrayOutput + ToOpensearchInstanceArrayOutputWithContext(context.Context) OpensearchInstanceArrayOutput +} + +type OpensearchInstanceArray []OpensearchInstanceInput + +func (OpensearchInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OpensearchInstance)(nil)).Elem() +} + +func (i OpensearchInstanceArray) ToOpensearchInstanceArrayOutput() OpensearchInstanceArrayOutput { + return i.ToOpensearchInstanceArrayOutputWithContext(context.Background()) +} + +func (i OpensearchInstanceArray) ToOpensearchInstanceArrayOutputWithContext(ctx context.Context) OpensearchInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceArrayOutput) +} + +// OpensearchInstanceMapInput is an input type that accepts OpensearchInstanceMap and OpensearchInstanceMapOutput values. +// You can construct a concrete instance of `OpensearchInstanceMapInput` via: +// +// OpensearchInstanceMap{ "key": OpensearchInstanceArgs{...} } +type OpensearchInstanceMapInput interface { + pulumi.Input + + ToOpensearchInstanceMapOutput() OpensearchInstanceMapOutput + ToOpensearchInstanceMapOutputWithContext(context.Context) OpensearchInstanceMapOutput +} + +type OpensearchInstanceMap map[string]OpensearchInstanceInput + +func (OpensearchInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OpensearchInstance)(nil)).Elem() +} + +func (i OpensearchInstanceMap) ToOpensearchInstanceMapOutput() OpensearchInstanceMapOutput { + return i.ToOpensearchInstanceMapOutputWithContext(context.Background()) +} + +func (i OpensearchInstanceMap) ToOpensearchInstanceMapOutputWithContext(ctx context.Context) OpensearchInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceMapOutput) +} + +type OpensearchInstanceOutput struct{ *pulumi.OutputState } + +func (OpensearchInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchInstance)(nil)).Elem() +} + +func (o OpensearchInstanceOutput) ToOpensearchInstanceOutput() OpensearchInstanceOutput { + return o +} + +func (o OpensearchInstanceOutput) ToOpensearchInstanceOutputWithContext(ctx context.Context) OpensearchInstanceOutput { + return o +} + +func (o OpensearchInstanceOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o OpensearchInstanceOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o OpensearchInstanceOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o OpensearchInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o OpensearchInstanceOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the OpenSearch instance. +func (o OpensearchInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o OpensearchInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o OpensearchInstanceOutput) Parameters() OpensearchInstanceParametersOutput { + return o.ApplyT(func(v *OpensearchInstance) OpensearchInstanceParametersOutput { return v.Parameters }).(OpensearchInstanceParametersOutput) +} + +// The selected plan ID. +func (o OpensearchInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o OpensearchInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o OpensearchInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o OpensearchInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *OpensearchInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type OpensearchInstanceArrayOutput struct{ *pulumi.OutputState } + +func (OpensearchInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OpensearchInstance)(nil)).Elem() +} + +func (o OpensearchInstanceArrayOutput) ToOpensearchInstanceArrayOutput() OpensearchInstanceArrayOutput { + return o +} + +func (o OpensearchInstanceArrayOutput) ToOpensearchInstanceArrayOutputWithContext(ctx context.Context) OpensearchInstanceArrayOutput { + return o +} + +func (o OpensearchInstanceArrayOutput) Index(i pulumi.IntInput) OpensearchInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OpensearchInstance { + return vs[0].([]*OpensearchInstance)[vs[1].(int)] + }).(OpensearchInstanceOutput) +} + +type OpensearchInstanceMapOutput struct{ *pulumi.OutputState } + +func (OpensearchInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OpensearchInstance)(nil)).Elem() +} + +func (o OpensearchInstanceMapOutput) ToOpensearchInstanceMapOutput() OpensearchInstanceMapOutput { + return o +} + +func (o OpensearchInstanceMapOutput) ToOpensearchInstanceMapOutputWithContext(ctx context.Context) OpensearchInstanceMapOutput { + return o +} + +func (o OpensearchInstanceMapOutput) MapIndex(k pulumi.StringInput) OpensearchInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OpensearchInstance { + return vs[0].(map[string]*OpensearchInstance)[vs[1].(string)] + }).(OpensearchInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchInstanceInput)(nil)).Elem(), &OpensearchInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchInstanceArrayInput)(nil)).Elem(), OpensearchInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchInstanceMapInput)(nil)).Elem(), OpensearchInstanceMap{}) + pulumi.RegisterOutputType(OpensearchInstanceOutput{}) + pulumi.RegisterOutputType(OpensearchInstanceArrayOutput{}) + pulumi.RegisterOutputType(OpensearchInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/postgresflexDatabase.go b/sdk/go/stackit/postgresflexDatabase.go new file mode 100644 index 0000000..b96d779 --- /dev/null +++ b/sdk/go/stackit/postgresflexDatabase.go @@ -0,0 +1,298 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type PostgresflexDatabase struct { + pulumi.CustomResourceState + + // Database ID. + DatabaseId pulumi.StringOutput `pulumi:"databaseId"` + // ID of the Postgres Flex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Database name. + Name pulumi.StringOutput `pulumi:"name"` + // Username of the database owner. + Owner pulumi.StringOutput `pulumi:"owner"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` +} + +// NewPostgresflexDatabase registers a new resource with the given unique name, arguments, and options. +func NewPostgresflexDatabase(ctx *pulumi.Context, + name string, args *PostgresflexDatabaseArgs, opts ...pulumi.ResourceOption) (*PostgresflexDatabase, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.Owner == nil { + return nil, errors.New("invalid value for required argument 'Owner'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource PostgresflexDatabase + err := ctx.RegisterResource("stackit:index/postgresflexDatabase:PostgresflexDatabase", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetPostgresflexDatabase gets an existing PostgresflexDatabase 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 GetPostgresflexDatabase(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *PostgresflexDatabaseState, opts ...pulumi.ResourceOption) (*PostgresflexDatabase, error) { + var resource PostgresflexDatabase + err := ctx.ReadResource("stackit:index/postgresflexDatabase:PostgresflexDatabase", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering PostgresflexDatabase resources. +type postgresflexDatabaseState struct { + // Database ID. + DatabaseId *string `pulumi:"databaseId"` + // ID of the Postgres Flex instance. + InstanceId *string `pulumi:"instanceId"` + // Database name. + Name *string `pulumi:"name"` + // Username of the database owner. + Owner *string `pulumi:"owner"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +type PostgresflexDatabaseState struct { + // Database ID. + DatabaseId pulumi.StringPtrInput + // ID of the Postgres Flex instance. + InstanceId pulumi.StringPtrInput + // Database name. + Name pulumi.StringPtrInput + // Username of the database owner. + Owner pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (PostgresflexDatabaseState) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexDatabaseState)(nil)).Elem() +} + +type postgresflexDatabaseArgs struct { + // ID of the Postgres Flex instance. + InstanceId string `pulumi:"instanceId"` + // Database name. + Name *string `pulumi:"name"` + // Username of the database owner. + Owner string `pulumi:"owner"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// The set of arguments for constructing a PostgresflexDatabase resource. +type PostgresflexDatabaseArgs struct { + // ID of the Postgres Flex instance. + InstanceId pulumi.StringInput + // Database name. + Name pulumi.StringPtrInput + // Username of the database owner. + Owner pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (PostgresflexDatabaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexDatabaseArgs)(nil)).Elem() +} + +type PostgresflexDatabaseInput interface { + pulumi.Input + + ToPostgresflexDatabaseOutput() PostgresflexDatabaseOutput + ToPostgresflexDatabaseOutputWithContext(ctx context.Context) PostgresflexDatabaseOutput +} + +func (*PostgresflexDatabase) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexDatabase)(nil)).Elem() +} + +func (i *PostgresflexDatabase) ToPostgresflexDatabaseOutput() PostgresflexDatabaseOutput { + return i.ToPostgresflexDatabaseOutputWithContext(context.Background()) +} + +func (i *PostgresflexDatabase) ToPostgresflexDatabaseOutputWithContext(ctx context.Context) PostgresflexDatabaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexDatabaseOutput) +} + +// PostgresflexDatabaseArrayInput is an input type that accepts PostgresflexDatabaseArray and PostgresflexDatabaseArrayOutput values. +// You can construct a concrete instance of `PostgresflexDatabaseArrayInput` via: +// +// PostgresflexDatabaseArray{ PostgresflexDatabaseArgs{...} } +type PostgresflexDatabaseArrayInput interface { + pulumi.Input + + ToPostgresflexDatabaseArrayOutput() PostgresflexDatabaseArrayOutput + ToPostgresflexDatabaseArrayOutputWithContext(context.Context) PostgresflexDatabaseArrayOutput +} + +type PostgresflexDatabaseArray []PostgresflexDatabaseInput + +func (PostgresflexDatabaseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexDatabase)(nil)).Elem() +} + +func (i PostgresflexDatabaseArray) ToPostgresflexDatabaseArrayOutput() PostgresflexDatabaseArrayOutput { + return i.ToPostgresflexDatabaseArrayOutputWithContext(context.Background()) +} + +func (i PostgresflexDatabaseArray) ToPostgresflexDatabaseArrayOutputWithContext(ctx context.Context) PostgresflexDatabaseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexDatabaseArrayOutput) +} + +// PostgresflexDatabaseMapInput is an input type that accepts PostgresflexDatabaseMap and PostgresflexDatabaseMapOutput values. +// You can construct a concrete instance of `PostgresflexDatabaseMapInput` via: +// +// PostgresflexDatabaseMap{ "key": PostgresflexDatabaseArgs{...} } +type PostgresflexDatabaseMapInput interface { + pulumi.Input + + ToPostgresflexDatabaseMapOutput() PostgresflexDatabaseMapOutput + ToPostgresflexDatabaseMapOutputWithContext(context.Context) PostgresflexDatabaseMapOutput +} + +type PostgresflexDatabaseMap map[string]PostgresflexDatabaseInput + +func (PostgresflexDatabaseMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexDatabase)(nil)).Elem() +} + +func (i PostgresflexDatabaseMap) ToPostgresflexDatabaseMapOutput() PostgresflexDatabaseMapOutput { + return i.ToPostgresflexDatabaseMapOutputWithContext(context.Background()) +} + +func (i PostgresflexDatabaseMap) ToPostgresflexDatabaseMapOutputWithContext(ctx context.Context) PostgresflexDatabaseMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexDatabaseMapOutput) +} + +type PostgresflexDatabaseOutput struct{ *pulumi.OutputState } + +func (PostgresflexDatabaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexDatabase)(nil)).Elem() +} + +func (o PostgresflexDatabaseOutput) ToPostgresflexDatabaseOutput() PostgresflexDatabaseOutput { + return o +} + +func (o PostgresflexDatabaseOutput) ToPostgresflexDatabaseOutputWithContext(ctx context.Context) PostgresflexDatabaseOutput { + return o +} + +// Database ID. +func (o PostgresflexDatabaseOutput) DatabaseId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.DatabaseId }).(pulumi.StringOutput) +} + +// ID of the Postgres Flex instance. +func (o PostgresflexDatabaseOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Database name. +func (o PostgresflexDatabaseOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Username of the database owner. +func (o PostgresflexDatabaseOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.Owner }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o PostgresflexDatabaseOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o PostgresflexDatabaseOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexDatabase) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +type PostgresflexDatabaseArrayOutput struct{ *pulumi.OutputState } + +func (PostgresflexDatabaseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexDatabase)(nil)).Elem() +} + +func (o PostgresflexDatabaseArrayOutput) ToPostgresflexDatabaseArrayOutput() PostgresflexDatabaseArrayOutput { + return o +} + +func (o PostgresflexDatabaseArrayOutput) ToPostgresflexDatabaseArrayOutputWithContext(ctx context.Context) PostgresflexDatabaseArrayOutput { + return o +} + +func (o PostgresflexDatabaseArrayOutput) Index(i pulumi.IntInput) PostgresflexDatabaseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PostgresflexDatabase { + return vs[0].([]*PostgresflexDatabase)[vs[1].(int)] + }).(PostgresflexDatabaseOutput) +} + +type PostgresflexDatabaseMapOutput struct{ *pulumi.OutputState } + +func (PostgresflexDatabaseMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexDatabase)(nil)).Elem() +} + +func (o PostgresflexDatabaseMapOutput) ToPostgresflexDatabaseMapOutput() PostgresflexDatabaseMapOutput { + return o +} + +func (o PostgresflexDatabaseMapOutput) ToPostgresflexDatabaseMapOutputWithContext(ctx context.Context) PostgresflexDatabaseMapOutput { + return o +} + +func (o PostgresflexDatabaseMapOutput) MapIndex(k pulumi.StringInput) PostgresflexDatabaseOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PostgresflexDatabase { + return vs[0].(map[string]*PostgresflexDatabase)[vs[1].(string)] + }).(PostgresflexDatabaseOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexDatabaseInput)(nil)).Elem(), &PostgresflexDatabase{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexDatabaseArrayInput)(nil)).Elem(), PostgresflexDatabaseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexDatabaseMapInput)(nil)).Elem(), PostgresflexDatabaseMap{}) + pulumi.RegisterOutputType(PostgresflexDatabaseOutput{}) + pulumi.RegisterOutputType(PostgresflexDatabaseArrayOutput{}) + pulumi.RegisterOutputType(PostgresflexDatabaseMapOutput{}) +} diff --git a/sdk/go/stackit/postgresflexInstance.go b/sdk/go/stackit/postgresflexInstance.go new file mode 100644 index 0000000..3a4c7f9 --- /dev/null +++ b/sdk/go/stackit/postgresflexInstance.go @@ -0,0 +1,340 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type PostgresflexInstance struct { + pulumi.CustomResourceState + + // The Access Control List (ACL) for the PostgresFlex instance. + Acls pulumi.StringArrayOutput `pulumi:"acls"` + BackupSchedule pulumi.StringOutput `pulumi:"backupSchedule"` + Flavor PostgresflexInstanceFlavorOutput `pulumi:"flavor"` + // ID of the PostgresFlex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + Replicas pulumi.IntOutput `pulumi:"replicas"` + Storage PostgresflexInstanceStorageOutput `pulumi:"storage"` + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewPostgresflexInstance registers a new resource with the given unique name, arguments, and options. +func NewPostgresflexInstance(ctx *pulumi.Context, + name string, args *PostgresflexInstanceArgs, opts ...pulumi.ResourceOption) (*PostgresflexInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Acls == nil { + return nil, errors.New("invalid value for required argument 'Acls'") + } + if args.BackupSchedule == nil { + return nil, errors.New("invalid value for required argument 'BackupSchedule'") + } + if args.Flavor == nil { + return nil, errors.New("invalid value for required argument 'Flavor'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Replicas == nil { + return nil, errors.New("invalid value for required argument 'Replicas'") + } + if args.Storage == nil { + return nil, errors.New("invalid value for required argument 'Storage'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource PostgresflexInstance + err := ctx.RegisterResource("stackit:index/postgresflexInstance:PostgresflexInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetPostgresflexInstance gets an existing PostgresflexInstance 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 GetPostgresflexInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *PostgresflexInstanceState, opts ...pulumi.ResourceOption) (*PostgresflexInstance, error) { + var resource PostgresflexInstance + err := ctx.ReadResource("stackit:index/postgresflexInstance:PostgresflexInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering PostgresflexInstance resources. +type postgresflexInstanceState struct { + // The Access Control List (ACL) for the PostgresFlex instance. + Acls []string `pulumi:"acls"` + BackupSchedule *string `pulumi:"backupSchedule"` + Flavor *PostgresflexInstanceFlavor `pulumi:"flavor"` + // ID of the PostgresFlex instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Replicas *int `pulumi:"replicas"` + Storage *PostgresflexInstanceStorage `pulumi:"storage"` + Version *string `pulumi:"version"` +} + +type PostgresflexInstanceState struct { + // The Access Control List (ACL) for the PostgresFlex instance. + Acls pulumi.StringArrayInput + BackupSchedule pulumi.StringPtrInput + Flavor PostgresflexInstanceFlavorPtrInput + // ID of the PostgresFlex instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + Replicas pulumi.IntPtrInput + Storage PostgresflexInstanceStoragePtrInput + Version pulumi.StringPtrInput +} + +func (PostgresflexInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexInstanceState)(nil)).Elem() +} + +type postgresflexInstanceArgs struct { + // The Access Control List (ACL) for the PostgresFlex instance. + Acls []string `pulumi:"acls"` + BackupSchedule string `pulumi:"backupSchedule"` + Flavor PostgresflexInstanceFlavor `pulumi:"flavor"` + // Instance name. + Name *string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Replicas int `pulumi:"replicas"` + Storage PostgresflexInstanceStorage `pulumi:"storage"` + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a PostgresflexInstance resource. +type PostgresflexInstanceArgs struct { + // The Access Control List (ACL) for the PostgresFlex instance. + Acls pulumi.StringArrayInput + BackupSchedule pulumi.StringInput + Flavor PostgresflexInstanceFlavorInput + // Instance name. + Name pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + Replicas pulumi.IntInput + Storage PostgresflexInstanceStorageInput + Version pulumi.StringInput +} + +func (PostgresflexInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexInstanceArgs)(nil)).Elem() +} + +type PostgresflexInstanceInput interface { + pulumi.Input + + ToPostgresflexInstanceOutput() PostgresflexInstanceOutput + ToPostgresflexInstanceOutputWithContext(ctx context.Context) PostgresflexInstanceOutput +} + +func (*PostgresflexInstance) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstance)(nil)).Elem() +} + +func (i *PostgresflexInstance) ToPostgresflexInstanceOutput() PostgresflexInstanceOutput { + return i.ToPostgresflexInstanceOutputWithContext(context.Background()) +} + +func (i *PostgresflexInstance) ToPostgresflexInstanceOutputWithContext(ctx context.Context) PostgresflexInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceOutput) +} + +// PostgresflexInstanceArrayInput is an input type that accepts PostgresflexInstanceArray and PostgresflexInstanceArrayOutput values. +// You can construct a concrete instance of `PostgresflexInstanceArrayInput` via: +// +// PostgresflexInstanceArray{ PostgresflexInstanceArgs{...} } +type PostgresflexInstanceArrayInput interface { + pulumi.Input + + ToPostgresflexInstanceArrayOutput() PostgresflexInstanceArrayOutput + ToPostgresflexInstanceArrayOutputWithContext(context.Context) PostgresflexInstanceArrayOutput +} + +type PostgresflexInstanceArray []PostgresflexInstanceInput + +func (PostgresflexInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexInstance)(nil)).Elem() +} + +func (i PostgresflexInstanceArray) ToPostgresflexInstanceArrayOutput() PostgresflexInstanceArrayOutput { + return i.ToPostgresflexInstanceArrayOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceArray) ToPostgresflexInstanceArrayOutputWithContext(ctx context.Context) PostgresflexInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceArrayOutput) +} + +// PostgresflexInstanceMapInput is an input type that accepts PostgresflexInstanceMap and PostgresflexInstanceMapOutput values. +// You can construct a concrete instance of `PostgresflexInstanceMapInput` via: +// +// PostgresflexInstanceMap{ "key": PostgresflexInstanceArgs{...} } +type PostgresflexInstanceMapInput interface { + pulumi.Input + + ToPostgresflexInstanceMapOutput() PostgresflexInstanceMapOutput + ToPostgresflexInstanceMapOutputWithContext(context.Context) PostgresflexInstanceMapOutput +} + +type PostgresflexInstanceMap map[string]PostgresflexInstanceInput + +func (PostgresflexInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexInstance)(nil)).Elem() +} + +func (i PostgresflexInstanceMap) ToPostgresflexInstanceMapOutput() PostgresflexInstanceMapOutput { + return i.ToPostgresflexInstanceMapOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceMap) ToPostgresflexInstanceMapOutputWithContext(ctx context.Context) PostgresflexInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceMapOutput) +} + +type PostgresflexInstanceOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstance)(nil)).Elem() +} + +func (o PostgresflexInstanceOutput) ToPostgresflexInstanceOutput() PostgresflexInstanceOutput { + return o +} + +func (o PostgresflexInstanceOutput) ToPostgresflexInstanceOutputWithContext(ctx context.Context) PostgresflexInstanceOutput { + return o +} + +// The Access Control List (ACL) for the PostgresFlex instance. +func (o PostgresflexInstanceOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringArrayOutput { return v.Acls }).(pulumi.StringArrayOutput) +} + +func (o PostgresflexInstanceOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o PostgresflexInstanceOutput) Flavor() PostgresflexInstanceFlavorOutput { + return o.ApplyT(func(v *PostgresflexInstance) PostgresflexInstanceFlavorOutput { return v.Flavor }).(PostgresflexInstanceFlavorOutput) +} + +// ID of the PostgresFlex instance. +func (o PostgresflexInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o PostgresflexInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o PostgresflexInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o PostgresflexInstanceOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +func (o PostgresflexInstanceOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.IntOutput { return v.Replicas }).(pulumi.IntOutput) +} + +func (o PostgresflexInstanceOutput) Storage() PostgresflexInstanceStorageOutput { + return o.ApplyT(func(v *PostgresflexInstance) PostgresflexInstanceStorageOutput { return v.Storage }).(PostgresflexInstanceStorageOutput) +} + +func (o PostgresflexInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type PostgresflexInstanceArrayOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexInstance)(nil)).Elem() +} + +func (o PostgresflexInstanceArrayOutput) ToPostgresflexInstanceArrayOutput() PostgresflexInstanceArrayOutput { + return o +} + +func (o PostgresflexInstanceArrayOutput) ToPostgresflexInstanceArrayOutputWithContext(ctx context.Context) PostgresflexInstanceArrayOutput { + return o +} + +func (o PostgresflexInstanceArrayOutput) Index(i pulumi.IntInput) PostgresflexInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PostgresflexInstance { + return vs[0].([]*PostgresflexInstance)[vs[1].(int)] + }).(PostgresflexInstanceOutput) +} + +type PostgresflexInstanceMapOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexInstance)(nil)).Elem() +} + +func (o PostgresflexInstanceMapOutput) ToPostgresflexInstanceMapOutput() PostgresflexInstanceMapOutput { + return o +} + +func (o PostgresflexInstanceMapOutput) ToPostgresflexInstanceMapOutputWithContext(ctx context.Context) PostgresflexInstanceMapOutput { + return o +} + +func (o PostgresflexInstanceMapOutput) MapIndex(k pulumi.StringInput) PostgresflexInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PostgresflexInstance { + return vs[0].(map[string]*PostgresflexInstance)[vs[1].(string)] + }).(PostgresflexInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceInput)(nil)).Elem(), &PostgresflexInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceArrayInput)(nil)).Elem(), PostgresflexInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceMapInput)(nil)).Elem(), PostgresflexInstanceMap{}) + pulumi.RegisterOutputType(PostgresflexInstanceOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceArrayOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/postgresflexUser.go b/sdk/go/stackit/postgresflexUser.go new file mode 100644 index 0000000..ee912b9 --- /dev/null +++ b/sdk/go/stackit/postgresflexUser.go @@ -0,0 +1,328 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Postgres Flex user resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type PostgresflexUser struct { + pulumi.CustomResourceState + + Host pulumi.StringOutput `pulumi:"host"` + // ID of the PostgresFlex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // Database access levels for the user. Supported values are: `login`, `createdb`. + Roles pulumi.StringArrayOutput `pulumi:"roles"` + Uri pulumi.StringOutput `pulumi:"uri"` + // User ID. + UserId pulumi.StringOutput `pulumi:"userId"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewPostgresflexUser registers a new resource with the given unique name, arguments, and options. +func NewPostgresflexUser(ctx *pulumi.Context, + name string, args *PostgresflexUserArgs, opts ...pulumi.ResourceOption) (*PostgresflexUser, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Roles == nil { + return nil, errors.New("invalid value for required argument 'Roles'") + } + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource PostgresflexUser + err := ctx.RegisterResource("stackit:index/postgresflexUser:PostgresflexUser", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetPostgresflexUser gets an existing PostgresflexUser 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 GetPostgresflexUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *PostgresflexUserState, opts ...pulumi.ResourceOption) (*PostgresflexUser, error) { + var resource PostgresflexUser + err := ctx.ReadResource("stackit:index/postgresflexUser:PostgresflexUser", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering PostgresflexUser resources. +type postgresflexUserState struct { + Host *string `pulumi:"host"` + // ID of the PostgresFlex instance. + InstanceId *string `pulumi:"instanceId"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Database access levels for the user. Supported values are: `login`, `createdb`. + Roles []string `pulumi:"roles"` + Uri *string `pulumi:"uri"` + // User ID. + UserId *string `pulumi:"userId"` + Username *string `pulumi:"username"` +} + +type PostgresflexUserState struct { + Host pulumi.StringPtrInput + // ID of the PostgresFlex instance. + InstanceId pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Database access levels for the user. Supported values are: `login`, `createdb`. + Roles pulumi.StringArrayInput + Uri pulumi.StringPtrInput + // User ID. + UserId pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (PostgresflexUserState) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexUserState)(nil)).Elem() +} + +type postgresflexUserArgs struct { + // ID of the PostgresFlex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Database access levels for the user. Supported values are: `login`, `createdb`. + Roles []string `pulumi:"roles"` + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a PostgresflexUser resource. +type PostgresflexUserArgs struct { + // ID of the PostgresFlex instance. + InstanceId pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Database access levels for the user. Supported values are: `login`, `createdb`. + Roles pulumi.StringArrayInput + Username pulumi.StringInput +} + +func (PostgresflexUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*postgresflexUserArgs)(nil)).Elem() +} + +type PostgresflexUserInput interface { + pulumi.Input + + ToPostgresflexUserOutput() PostgresflexUserOutput + ToPostgresflexUserOutputWithContext(ctx context.Context) PostgresflexUserOutput +} + +func (*PostgresflexUser) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexUser)(nil)).Elem() +} + +func (i *PostgresflexUser) ToPostgresflexUserOutput() PostgresflexUserOutput { + return i.ToPostgresflexUserOutputWithContext(context.Background()) +} + +func (i *PostgresflexUser) ToPostgresflexUserOutputWithContext(ctx context.Context) PostgresflexUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexUserOutput) +} + +// PostgresflexUserArrayInput is an input type that accepts PostgresflexUserArray and PostgresflexUserArrayOutput values. +// You can construct a concrete instance of `PostgresflexUserArrayInput` via: +// +// PostgresflexUserArray{ PostgresflexUserArgs{...} } +type PostgresflexUserArrayInput interface { + pulumi.Input + + ToPostgresflexUserArrayOutput() PostgresflexUserArrayOutput + ToPostgresflexUserArrayOutputWithContext(context.Context) PostgresflexUserArrayOutput +} + +type PostgresflexUserArray []PostgresflexUserInput + +func (PostgresflexUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexUser)(nil)).Elem() +} + +func (i PostgresflexUserArray) ToPostgresflexUserArrayOutput() PostgresflexUserArrayOutput { + return i.ToPostgresflexUserArrayOutputWithContext(context.Background()) +} + +func (i PostgresflexUserArray) ToPostgresflexUserArrayOutputWithContext(ctx context.Context) PostgresflexUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexUserArrayOutput) +} + +// PostgresflexUserMapInput is an input type that accepts PostgresflexUserMap and PostgresflexUserMapOutput values. +// You can construct a concrete instance of `PostgresflexUserMapInput` via: +// +// PostgresflexUserMap{ "key": PostgresflexUserArgs{...} } +type PostgresflexUserMapInput interface { + pulumi.Input + + ToPostgresflexUserMapOutput() PostgresflexUserMapOutput + ToPostgresflexUserMapOutputWithContext(context.Context) PostgresflexUserMapOutput +} + +type PostgresflexUserMap map[string]PostgresflexUserInput + +func (PostgresflexUserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexUser)(nil)).Elem() +} + +func (i PostgresflexUserMap) ToPostgresflexUserMapOutput() PostgresflexUserMapOutput { + return i.ToPostgresflexUserMapOutputWithContext(context.Background()) +} + +func (i PostgresflexUserMap) ToPostgresflexUserMapOutputWithContext(ctx context.Context) PostgresflexUserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexUserMapOutput) +} + +type PostgresflexUserOutput struct{ *pulumi.OutputState } + +func (PostgresflexUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexUser)(nil)).Elem() +} + +func (o PostgresflexUserOutput) ToPostgresflexUserOutput() PostgresflexUserOutput { + return o +} + +func (o PostgresflexUserOutput) ToPostgresflexUserOutputWithContext(ctx context.Context) PostgresflexUserOutput { + return o +} + +func (o PostgresflexUserOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +// ID of the PostgresFlex instance. +func (o PostgresflexUserOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o PostgresflexUserOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o PostgresflexUserOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o PostgresflexUserOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o PostgresflexUserOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// Database access levels for the user. Supported values are: `login`, `createdb`. +func (o PostgresflexUserOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringArrayOutput { return v.Roles }).(pulumi.StringArrayOutput) +} + +func (o PostgresflexUserOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +// User ID. +func (o PostgresflexUserOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.UserId }).(pulumi.StringOutput) +} + +func (o PostgresflexUserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *PostgresflexUser) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type PostgresflexUserArrayOutput struct{ *pulumi.OutputState } + +func (PostgresflexUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PostgresflexUser)(nil)).Elem() +} + +func (o PostgresflexUserArrayOutput) ToPostgresflexUserArrayOutput() PostgresflexUserArrayOutput { + return o +} + +func (o PostgresflexUserArrayOutput) ToPostgresflexUserArrayOutputWithContext(ctx context.Context) PostgresflexUserArrayOutput { + return o +} + +func (o PostgresflexUserArrayOutput) Index(i pulumi.IntInput) PostgresflexUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PostgresflexUser { + return vs[0].([]*PostgresflexUser)[vs[1].(int)] + }).(PostgresflexUserOutput) +} + +type PostgresflexUserMapOutput struct{ *pulumi.OutputState } + +func (PostgresflexUserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PostgresflexUser)(nil)).Elem() +} + +func (o PostgresflexUserMapOutput) ToPostgresflexUserMapOutput() PostgresflexUserMapOutput { + return o +} + +func (o PostgresflexUserMapOutput) ToPostgresflexUserMapOutputWithContext(ctx context.Context) PostgresflexUserMapOutput { + return o +} + +func (o PostgresflexUserMapOutput) MapIndex(k pulumi.StringInput) PostgresflexUserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PostgresflexUser { + return vs[0].(map[string]*PostgresflexUser)[vs[1].(string)] + }).(PostgresflexUserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexUserInput)(nil)).Elem(), &PostgresflexUser{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexUserArrayInput)(nil)).Elem(), PostgresflexUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexUserMapInput)(nil)).Elem(), PostgresflexUserMap{}) + pulumi.RegisterOutputType(PostgresflexUserOutput{}) + pulumi.RegisterOutputType(PostgresflexUserArrayOutput{}) + pulumi.RegisterOutputType(PostgresflexUserMapOutput{}) +} diff --git a/sdk/go/stackit/provider.go b/sdk/go/stackit/provider.go new file mode 100644 index 0000000..eeaed0b --- /dev/null +++ b/sdk/go/stackit/provider.go @@ -0,0 +1,549 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// The provider type for the stackit package. By default, resources use package-wide configuration +// settings, however an explicit `Provider` instance may be created and passed during resource +// construction to achieve fine-grained programmatic control over provider settings. See the +// [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. +type Provider struct { + pulumi.ProviderResourceState + + // Custom endpoint for the Argus service + // + // Deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. + ArgusCustomEndpoint pulumi.StringPtrOutput `pulumi:"argusCustomEndpoint"` + // Custom endpoint for the Membership service + AuthorizationCustomEndpoint pulumi.StringPtrOutput `pulumi:"authorizationCustomEndpoint"` + // Custom endpoint for the CDN service + CdnCustomEndpoint pulumi.StringPtrOutput `pulumi:"cdnCustomEndpoint"` + // Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + // value is `~/.stackit/credentials.json`. + CredentialsPath pulumi.StringPtrOutput `pulumi:"credentialsPath"` + // Region will be used as the default location for regional services. Not all services require a region, some are global + DefaultRegion pulumi.StringPtrOutput `pulumi:"defaultRegion"` + // Custom endpoint for the DNS service + DnsCustomEndpoint pulumi.StringPtrOutput `pulumi:"dnsCustomEndpoint"` + // Custom endpoint for the Git service + GitCustomEndpoint pulumi.StringPtrOutput `pulumi:"gitCustomEndpoint"` + // Custom endpoint for the IaaS service + IaasCustomEndpoint pulumi.StringPtrOutput `pulumi:"iaasCustomEndpoint"` + // Custom endpoint for the Load Balancer service + LoadbalancerCustomEndpoint pulumi.StringPtrOutput `pulumi:"loadbalancerCustomEndpoint"` + // Custom endpoint for the LogMe service + LogmeCustomEndpoint pulumi.StringPtrOutput `pulumi:"logmeCustomEndpoint"` + // Custom endpoint for the MariaDB service + MariadbCustomEndpoint pulumi.StringPtrOutput `pulumi:"mariadbCustomEndpoint"` + // Custom endpoint for the AI Model Serving service + ModelservingCustomEndpoint pulumi.StringPtrOutput `pulumi:"modelservingCustomEndpoint"` + // Custom endpoint for the MongoDB Flex service + MongodbflexCustomEndpoint pulumi.StringPtrOutput `pulumi:"mongodbflexCustomEndpoint"` + // Custom endpoint for the Object Storage service + ObjectstorageCustomEndpoint pulumi.StringPtrOutput `pulumi:"objectstorageCustomEndpoint"` + // Custom endpoint for the Observability service + ObservabilityCustomEndpoint pulumi.StringPtrOutput `pulumi:"observabilityCustomEndpoint"` + // Custom endpoint for the OpenSearch service + OpensearchCustomEndpoint pulumi.StringPtrOutput `pulumi:"opensearchCustomEndpoint"` + // Custom endpoint for the PostgresFlex service + PostgresflexCustomEndpoint pulumi.StringPtrOutput `pulumi:"postgresflexCustomEndpoint"` + // Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + // included in the service account key. + PrivateKey pulumi.StringPtrOutput `pulumi:"privateKey"` + // Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + // key that is included in the service account key. + PrivateKeyPath pulumi.StringPtrOutput `pulumi:"privateKeyPath"` + // Custom endpoint for the RabbitMQ service + RabbitmqCustomEndpoint pulumi.StringPtrOutput `pulumi:"rabbitmqCustomEndpoint"` + // Custom endpoint for the Redis service + RedisCustomEndpoint pulumi.StringPtrOutput `pulumi:"redisCustomEndpoint"` + // Region will be used as the default location for regional services. Not all services require a region, some are global + // + // Deprecated: This attribute is deprecated. Use 'default_region' instead + Region pulumi.StringPtrOutput `pulumi:"region"` + // Custom endpoint for the Resource Manager service + ResourcemanagerCustomEndpoint pulumi.StringPtrOutput `pulumi:"resourcemanagerCustomEndpoint"` + // Custom endpoint for the Secrets Manager service + SecretsmanagerCustomEndpoint pulumi.StringPtrOutput `pulumi:"secretsmanagerCustomEndpoint"` + // Custom endpoint for the Server Backup service + ServerBackupCustomEndpoint pulumi.StringPtrOutput `pulumi:"serverBackupCustomEndpoint"` + // Custom endpoint for the Server Update service + ServerUpdateCustomEndpoint pulumi.StringPtrOutput `pulumi:"serverUpdateCustomEndpoint"` + // Custom endpoint for the Service Account service + ServiceAccountCustomEndpoint pulumi.StringPtrOutput `pulumi:"serviceAccountCustomEndpoint"` + // Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + // if you want to use the resource manager project resource. + // + // Deprecated: The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. + ServiceAccountEmail pulumi.StringPtrOutput `pulumi:"serviceAccountEmail"` + // Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + ServiceAccountKey pulumi.StringPtrOutput `pulumi:"serviceAccountKey"` + // Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + // operations. + ServiceAccountKeyPath pulumi.StringPtrOutput `pulumi:"serviceAccountKeyPath"` + // Token used for authentication. If set, the token flow will be used to authenticate all operations. + ServiceAccountToken pulumi.StringPtrOutput `pulumi:"serviceAccountToken"` + // Custom endpoint for the Service Enablement API + ServiceEnablementCustomEndpoint pulumi.StringPtrOutput `pulumi:"serviceEnablementCustomEndpoint"` + // Custom endpoint for the Kubernetes Engine (SKE) service + SkeCustomEndpoint pulumi.StringPtrOutput `pulumi:"skeCustomEndpoint"` + // Custom endpoint for the SQL Server Flex service + SqlserverflexCustomEndpoint pulumi.StringPtrOutput `pulumi:"sqlserverflexCustomEndpoint"` + // Custom endpoint for the token API, which is used to request access tokens when using the key flow + TokenCustomEndpoint pulumi.StringPtrOutput `pulumi:"tokenCustomEndpoint"` +} + +// NewProvider registers a new resource with the given unique name, arguments, and options. +func NewProvider(ctx *pulumi.Context, + name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error) { + if args == nil { + args = &ProviderArgs{} + } + + opts = internal.PkgResourceDefaultOpts(opts) + var resource Provider + err := ctx.RegisterResource("pulumi:providers:stackit", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +type providerArgs struct { + // Custom endpoint for the Argus service + // + // Deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. + ArgusCustomEndpoint *string `pulumi:"argusCustomEndpoint"` + // Custom endpoint for the Membership service + AuthorizationCustomEndpoint *string `pulumi:"authorizationCustomEndpoint"` + // Custom endpoint for the CDN service + CdnCustomEndpoint *string `pulumi:"cdnCustomEndpoint"` + // Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + // value is `~/.stackit/credentials.json`. + CredentialsPath *string `pulumi:"credentialsPath"` + // Region will be used as the default location for regional services. Not all services require a region, some are global + DefaultRegion *string `pulumi:"defaultRegion"` + // Custom endpoint for the DNS service + DnsCustomEndpoint *string `pulumi:"dnsCustomEndpoint"` + // Enable beta resources. Default is false. + EnableBetaResources *bool `pulumi:"enableBetaResources"` + // Enables experiments. These are unstable features without official support. More information can be found in the README. + // Available Experiments: [iam] + Experiments []string `pulumi:"experiments"` + // Custom endpoint for the Git service + GitCustomEndpoint *string `pulumi:"gitCustomEndpoint"` + // Custom endpoint for the IaaS service + IaasCustomEndpoint *string `pulumi:"iaasCustomEndpoint"` + // Custom endpoint for the Load Balancer service + LoadbalancerCustomEndpoint *string `pulumi:"loadbalancerCustomEndpoint"` + // Custom endpoint for the LogMe service + LogmeCustomEndpoint *string `pulumi:"logmeCustomEndpoint"` + // Custom endpoint for the MariaDB service + MariadbCustomEndpoint *string `pulumi:"mariadbCustomEndpoint"` + // Custom endpoint for the AI Model Serving service + ModelservingCustomEndpoint *string `pulumi:"modelservingCustomEndpoint"` + // Custom endpoint for the MongoDB Flex service + MongodbflexCustomEndpoint *string `pulumi:"mongodbflexCustomEndpoint"` + // Custom endpoint for the Object Storage service + ObjectstorageCustomEndpoint *string `pulumi:"objectstorageCustomEndpoint"` + // Custom endpoint for the Observability service + ObservabilityCustomEndpoint *string `pulumi:"observabilityCustomEndpoint"` + // Custom endpoint for the OpenSearch service + OpensearchCustomEndpoint *string `pulumi:"opensearchCustomEndpoint"` + // Custom endpoint for the PostgresFlex service + PostgresflexCustomEndpoint *string `pulumi:"postgresflexCustomEndpoint"` + // Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + // included in the service account key. + PrivateKey *string `pulumi:"privateKey"` + // Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + // key that is included in the service account key. + PrivateKeyPath *string `pulumi:"privateKeyPath"` + // Custom endpoint for the RabbitMQ service + RabbitmqCustomEndpoint *string `pulumi:"rabbitmqCustomEndpoint"` + // Custom endpoint for the Redis service + RedisCustomEndpoint *string `pulumi:"redisCustomEndpoint"` + // Region will be used as the default location for regional services. Not all services require a region, some are global + // + // Deprecated: This attribute is deprecated. Use 'default_region' instead + Region *string `pulumi:"region"` + // Custom endpoint for the Resource Manager service + ResourcemanagerCustomEndpoint *string `pulumi:"resourcemanagerCustomEndpoint"` + // Custom endpoint for the Secrets Manager service + SecretsmanagerCustomEndpoint *string `pulumi:"secretsmanagerCustomEndpoint"` + // Custom endpoint for the Server Backup service + ServerBackupCustomEndpoint *string `pulumi:"serverBackupCustomEndpoint"` + // Custom endpoint for the Server Update service + ServerUpdateCustomEndpoint *string `pulumi:"serverUpdateCustomEndpoint"` + // Custom endpoint for the Service Account service + ServiceAccountCustomEndpoint *string `pulumi:"serviceAccountCustomEndpoint"` + // Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + // if you want to use the resource manager project resource. + // + // Deprecated: The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. + ServiceAccountEmail *string `pulumi:"serviceAccountEmail"` + // Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + ServiceAccountKey *string `pulumi:"serviceAccountKey"` + // Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + // operations. + ServiceAccountKeyPath *string `pulumi:"serviceAccountKeyPath"` + // Token used for authentication. If set, the token flow will be used to authenticate all operations. + ServiceAccountToken *string `pulumi:"serviceAccountToken"` + // Custom endpoint for the Service Enablement API + ServiceEnablementCustomEndpoint *string `pulumi:"serviceEnablementCustomEndpoint"` + // Custom endpoint for the Kubernetes Engine (SKE) service + SkeCustomEndpoint *string `pulumi:"skeCustomEndpoint"` + // Custom endpoint for the SQL Server Flex service + SqlserverflexCustomEndpoint *string `pulumi:"sqlserverflexCustomEndpoint"` + // Custom endpoint for the token API, which is used to request access tokens when using the key flow + TokenCustomEndpoint *string `pulumi:"tokenCustomEndpoint"` +} + +// The set of arguments for constructing a Provider resource. +type ProviderArgs struct { + // Custom endpoint for the Argus service + // + // Deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. + ArgusCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Membership service + AuthorizationCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the CDN service + CdnCustomEndpoint pulumi.StringPtrInput + // Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + // value is `~/.stackit/credentials.json`. + CredentialsPath pulumi.StringPtrInput + // Region will be used as the default location for regional services. Not all services require a region, some are global + DefaultRegion pulumi.StringPtrInput + // Custom endpoint for the DNS service + DnsCustomEndpoint pulumi.StringPtrInput + // Enable beta resources. Default is false. + EnableBetaResources pulumi.BoolPtrInput + // Enables experiments. These are unstable features without official support. More information can be found in the README. + // Available Experiments: [iam] + Experiments pulumi.StringArrayInput + // Custom endpoint for the Git service + GitCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the IaaS service + IaasCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Load Balancer service + LoadbalancerCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the LogMe service + LogmeCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the MariaDB service + MariadbCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the AI Model Serving service + ModelservingCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the MongoDB Flex service + MongodbflexCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Object Storage service + ObjectstorageCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Observability service + ObservabilityCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the OpenSearch service + OpensearchCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the PostgresFlex service + PostgresflexCustomEndpoint pulumi.StringPtrInput + // Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + // included in the service account key. + PrivateKey pulumi.StringPtrInput + // Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + // key that is included in the service account key. + PrivateKeyPath pulumi.StringPtrInput + // Custom endpoint for the RabbitMQ service + RabbitmqCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Redis service + RedisCustomEndpoint pulumi.StringPtrInput + // Region will be used as the default location for regional services. Not all services require a region, some are global + // + // Deprecated: This attribute is deprecated. Use 'default_region' instead + Region pulumi.StringPtrInput + // Custom endpoint for the Resource Manager service + ResourcemanagerCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Secrets Manager service + SecretsmanagerCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Server Backup service + ServerBackupCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Server Update service + ServerUpdateCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Service Account service + ServiceAccountCustomEndpoint pulumi.StringPtrInput + // Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + // if you want to use the resource manager project resource. + // + // Deprecated: The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. + ServiceAccountEmail pulumi.StringPtrInput + // Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + ServiceAccountKey pulumi.StringPtrInput + // Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + // operations. + ServiceAccountKeyPath pulumi.StringPtrInput + // Token used for authentication. If set, the token flow will be used to authenticate all operations. + ServiceAccountToken pulumi.StringPtrInput + // Custom endpoint for the Service Enablement API + ServiceEnablementCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the Kubernetes Engine (SKE) service + SkeCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the SQL Server Flex service + SqlserverflexCustomEndpoint pulumi.StringPtrInput + // Custom endpoint for the token API, which is used to request access tokens when using the key flow + TokenCustomEndpoint pulumi.StringPtrInput +} + +func (ProviderArgs) ElementType() reflect.Type { + return reflect.TypeOf((*providerArgs)(nil)).Elem() +} + +// This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. +func (r *Provider) TerraformConfig(ctx *pulumi.Context) (ProviderTerraformConfigResultOutput, error) { + out, err := ctx.Call("pulumi:providers:stackit/terraformConfig", nil, ProviderTerraformConfigResultOutput{}, r) + if err != nil { + return ProviderTerraformConfigResultOutput{}, err + } + return out.(ProviderTerraformConfigResultOutput), nil +} + +type ProviderTerraformConfigResult struct { + Result map[string]interface{} `pulumi:"result"` +} + +type ProviderTerraformConfigResultOutput struct{ *pulumi.OutputState } + +func (ProviderTerraformConfigResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ProviderTerraformConfigResult)(nil)).Elem() +} + +func (o ProviderTerraformConfigResultOutput) Result() pulumi.MapOutput { + return o.ApplyT(func(v ProviderTerraformConfigResult) map[string]interface{} { return v.Result }).(pulumi.MapOutput) +} + +type ProviderInput interface { + pulumi.Input + + ToProviderOutput() ProviderOutput + ToProviderOutputWithContext(ctx context.Context) ProviderOutput +} + +func (*Provider) ElementType() reflect.Type { + return reflect.TypeOf((**Provider)(nil)).Elem() +} + +func (i *Provider) ToProviderOutput() ProviderOutput { + return i.ToProviderOutputWithContext(context.Background()) +} + +func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput) +} + +type ProviderOutput struct{ *pulumi.OutputState } + +func (ProviderOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Provider)(nil)).Elem() +} + +func (o ProviderOutput) ToProviderOutput() ProviderOutput { + return o +} + +func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput { + return o +} + +// Custom endpoint for the Argus service +// +// Deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. +func (o ProviderOutput) ArgusCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ArgusCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Membership service +func (o ProviderOutput) AuthorizationCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.AuthorizationCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the CDN service +func (o ProviderOutput) CdnCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.CdnCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default +// value is `~/.stackit/credentials.json`. +func (o ProviderOutput) CredentialsPath() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.CredentialsPath }).(pulumi.StringPtrOutput) +} + +// Region will be used as the default location for regional services. Not all services require a region, some are global +func (o ProviderOutput) DefaultRegion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.DefaultRegion }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the DNS service +func (o ProviderOutput) DnsCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.DnsCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Git service +func (o ProviderOutput) GitCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.GitCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the IaaS service +func (o ProviderOutput) IaasCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.IaasCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Load Balancer service +func (o ProviderOutput) LoadbalancerCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.LoadbalancerCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the LogMe service +func (o ProviderOutput) LogmeCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.LogmeCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the MariaDB service +func (o ProviderOutput) MariadbCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.MariadbCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the AI Model Serving service +func (o ProviderOutput) ModelservingCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ModelservingCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the MongoDB Flex service +func (o ProviderOutput) MongodbflexCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.MongodbflexCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Object Storage service +func (o ProviderOutput) ObjectstorageCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ObjectstorageCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Observability service +func (o ProviderOutput) ObservabilityCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ObservabilityCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the OpenSearch service +func (o ProviderOutput) OpensearchCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.OpensearchCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the PostgresFlex service +func (o ProviderOutput) PostgresflexCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.PostgresflexCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is +// included in the service account key. +func (o ProviderOutput) PrivateKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.PrivateKey }).(pulumi.StringPtrOutput) +} + +// Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private +// key that is included in the service account key. +func (o ProviderOutput) PrivateKeyPath() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.PrivateKeyPath }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the RabbitMQ service +func (o ProviderOutput) RabbitmqCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.RabbitmqCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Redis service +func (o ProviderOutput) RedisCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.RedisCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Region will be used as the default location for regional services. Not all services require a region, some are global +// +// Deprecated: This attribute is deprecated. Use 'default_region' instead +func (o ProviderOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.Region }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Resource Manager service +func (o ProviderOutput) ResourcemanagerCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ResourcemanagerCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Secrets Manager service +func (o ProviderOutput) SecretsmanagerCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.SecretsmanagerCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Server Backup service +func (o ProviderOutput) ServerBackupCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServerBackupCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Server Update service +func (o ProviderOutput) ServerUpdateCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServerUpdateCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Service Account service +func (o ProviderOutput) ServiceAccountCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceAccountCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required +// if you want to use the resource manager project resource. +// +// Deprecated: The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. +func (o ProviderOutput) ServiceAccountEmail() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceAccountEmail }).(pulumi.StringPtrOutput) +} + +// Service account key used for authentication. If set, the key flow will be used to authenticate all operations. +func (o ProviderOutput) ServiceAccountKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceAccountKey }).(pulumi.StringPtrOutput) +} + +// Path for the service account key used for authentication. If set, the key flow will be used to authenticate all +// operations. +func (o ProviderOutput) ServiceAccountKeyPath() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceAccountKeyPath }).(pulumi.StringPtrOutput) +} + +// Token used for authentication. If set, the token flow will be used to authenticate all operations. +func (o ProviderOutput) ServiceAccountToken() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceAccountToken }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Service Enablement API +func (o ProviderOutput) ServiceEnablementCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.ServiceEnablementCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the Kubernetes Engine (SKE) service +func (o ProviderOutput) SkeCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.SkeCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the SQL Server Flex service +func (o ProviderOutput) SqlserverflexCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.SqlserverflexCustomEndpoint }).(pulumi.StringPtrOutput) +} + +// Custom endpoint for the token API, which is used to request access tokens when using the key flow +func (o ProviderOutput) TokenCustomEndpoint() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.TokenCustomEndpoint }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ProviderInput)(nil)).Elem(), &Provider{}) + pulumi.RegisterOutputType(ProviderOutput{}) + pulumi.RegisterOutputType(ProviderTerraformConfigResultOutput{}) +} diff --git a/sdk/go/stackit/publicIp.go b/sdk/go/stackit/publicIp.go new file mode 100644 index 0000000..1ac3131 --- /dev/null +++ b/sdk/go/stackit/publicIp.go @@ -0,0 +1,267 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Public IP resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type PublicIp struct { + pulumi.CustomResourceState + + // The IP address. + Ip pulumi.StringOutput `pulumi:"ip"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + NetworkInterfaceId pulumi.StringOutput `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The public IP ID. + PublicIpId pulumi.StringOutput `pulumi:"publicIpId"` +} + +// NewPublicIp registers a new resource with the given unique name, arguments, and options. +func NewPublicIp(ctx *pulumi.Context, + name string, args *PublicIpArgs, opts ...pulumi.ResourceOption) (*PublicIp, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource PublicIp + err := ctx.RegisterResource("stackit:index/publicIp:PublicIp", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetPublicIp gets an existing PublicIp 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 GetPublicIp(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *PublicIpState, opts ...pulumi.ResourceOption) (*PublicIp, error) { + var resource PublicIp + err := ctx.ReadResource("stackit:index/publicIp:PublicIp", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering PublicIp resources. +type publicIpState struct { + // The IP address. + Ip *string `pulumi:"ip"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + NetworkInterfaceId *string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId *string `pulumi:"projectId"` + // The public IP ID. + PublicIpId *string `pulumi:"publicIpId"` +} + +type PublicIpState struct { + // The IP address. + Ip pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + NetworkInterfaceId pulumi.StringPtrInput + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringPtrInput + // The public IP ID. + PublicIpId pulumi.StringPtrInput +} + +func (PublicIpState) ElementType() reflect.Type { + return reflect.TypeOf((*publicIpState)(nil)).Elem() +} + +type publicIpArgs struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + NetworkInterfaceId *string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a PublicIp resource. +type PublicIpArgs struct { + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + NetworkInterfaceId pulumi.StringPtrInput + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringInput +} + +func (PublicIpArgs) ElementType() reflect.Type { + return reflect.TypeOf((*publicIpArgs)(nil)).Elem() +} + +type PublicIpInput interface { + pulumi.Input + + ToPublicIpOutput() PublicIpOutput + ToPublicIpOutputWithContext(ctx context.Context) PublicIpOutput +} + +func (*PublicIp) ElementType() reflect.Type { + return reflect.TypeOf((**PublicIp)(nil)).Elem() +} + +func (i *PublicIp) ToPublicIpOutput() PublicIpOutput { + return i.ToPublicIpOutputWithContext(context.Background()) +} + +func (i *PublicIp) ToPublicIpOutputWithContext(ctx context.Context) PublicIpOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpOutput) +} + +// PublicIpArrayInput is an input type that accepts PublicIpArray and PublicIpArrayOutput values. +// You can construct a concrete instance of `PublicIpArrayInput` via: +// +// PublicIpArray{ PublicIpArgs{...} } +type PublicIpArrayInput interface { + pulumi.Input + + ToPublicIpArrayOutput() PublicIpArrayOutput + ToPublicIpArrayOutputWithContext(context.Context) PublicIpArrayOutput +} + +type PublicIpArray []PublicIpInput + +func (PublicIpArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PublicIp)(nil)).Elem() +} + +func (i PublicIpArray) ToPublicIpArrayOutput() PublicIpArrayOutput { + return i.ToPublicIpArrayOutputWithContext(context.Background()) +} + +func (i PublicIpArray) ToPublicIpArrayOutputWithContext(ctx context.Context) PublicIpArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpArrayOutput) +} + +// PublicIpMapInput is an input type that accepts PublicIpMap and PublicIpMapOutput values. +// You can construct a concrete instance of `PublicIpMapInput` via: +// +// PublicIpMap{ "key": PublicIpArgs{...} } +type PublicIpMapInput interface { + pulumi.Input + + ToPublicIpMapOutput() PublicIpMapOutput + ToPublicIpMapOutputWithContext(context.Context) PublicIpMapOutput +} + +type PublicIpMap map[string]PublicIpInput + +func (PublicIpMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PublicIp)(nil)).Elem() +} + +func (i PublicIpMap) ToPublicIpMapOutput() PublicIpMapOutput { + return i.ToPublicIpMapOutputWithContext(context.Background()) +} + +func (i PublicIpMap) ToPublicIpMapOutputWithContext(ctx context.Context) PublicIpMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpMapOutput) +} + +type PublicIpOutput struct{ *pulumi.OutputState } + +func (PublicIpOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PublicIp)(nil)).Elem() +} + +func (o PublicIpOutput) ToPublicIpOutput() PublicIpOutput { + return o +} + +func (o PublicIpOutput) ToPublicIpOutputWithContext(ctx context.Context) PublicIpOutput { + return o +} + +// The IP address. +func (o PublicIpOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIp) pulumi.StringOutput { return v.Ip }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o PublicIpOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *PublicIp) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +func (o PublicIpOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIp) pulumi.StringOutput { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the public IP is associated. +func (o PublicIpOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIp) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The public IP ID. +func (o PublicIpOutput) PublicIpId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIp) pulumi.StringOutput { return v.PublicIpId }).(pulumi.StringOutput) +} + +type PublicIpArrayOutput struct{ *pulumi.OutputState } + +func (PublicIpArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PublicIp)(nil)).Elem() +} + +func (o PublicIpArrayOutput) ToPublicIpArrayOutput() PublicIpArrayOutput { + return o +} + +func (o PublicIpArrayOutput) ToPublicIpArrayOutputWithContext(ctx context.Context) PublicIpArrayOutput { + return o +} + +func (o PublicIpArrayOutput) Index(i pulumi.IntInput) PublicIpOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PublicIp { + return vs[0].([]*PublicIp)[vs[1].(int)] + }).(PublicIpOutput) +} + +type PublicIpMapOutput struct{ *pulumi.OutputState } + +func (PublicIpMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PublicIp)(nil)).Elem() +} + +func (o PublicIpMapOutput) ToPublicIpMapOutput() PublicIpMapOutput { + return o +} + +func (o PublicIpMapOutput) ToPublicIpMapOutputWithContext(ctx context.Context) PublicIpMapOutput { + return o +} + +func (o PublicIpMapOutput) MapIndex(k pulumi.StringInput) PublicIpOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PublicIp { + return vs[0].(map[string]*PublicIp)[vs[1].(string)] + }).(PublicIpOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpInput)(nil)).Elem(), &PublicIp{}) + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpArrayInput)(nil)).Elem(), PublicIpArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpMapInput)(nil)).Elem(), PublicIpMap{}) + pulumi.RegisterOutputType(PublicIpOutput{}) + pulumi.RegisterOutputType(PublicIpArrayOutput{}) + pulumi.RegisterOutputType(PublicIpMapOutput{}) +} diff --git a/sdk/go/stackit/publicIpAssociate.go b/sdk/go/stackit/publicIpAssociate.go new file mode 100644 index 0000000..c5ac4de --- /dev/null +++ b/sdk/go/stackit/publicIpAssociate.go @@ -0,0 +1,271 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration. +// +// !> The `PublicIpAssociate` resource should not be used together with the `PublicIp` resource for the same public IP or for the same network interface. +// Using both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association. +// +// ## Example Usage +type PublicIpAssociate struct { + pulumi.CustomResourceState + + // The IP address. + Ip pulumi.StringOutput `pulumi:"ip"` + // The ID of the network interface (or virtual IP) to which the public IP should be attached to. + NetworkInterfaceId pulumi.StringOutput `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The public IP ID. + PublicIpId pulumi.StringOutput `pulumi:"publicIpId"` +} + +// NewPublicIpAssociate registers a new resource with the given unique name, arguments, and options. +func NewPublicIpAssociate(ctx *pulumi.Context, + name string, args *PublicIpAssociateArgs, opts ...pulumi.ResourceOption) (*PublicIpAssociate, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NetworkInterfaceId == nil { + return nil, errors.New("invalid value for required argument 'NetworkInterfaceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.PublicIpId == nil { + return nil, errors.New("invalid value for required argument 'PublicIpId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource PublicIpAssociate + err := ctx.RegisterResource("stackit:index/publicIpAssociate:PublicIpAssociate", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetPublicIpAssociate gets an existing PublicIpAssociate 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 GetPublicIpAssociate(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *PublicIpAssociateState, opts ...pulumi.ResourceOption) (*PublicIpAssociate, error) { + var resource PublicIpAssociate + err := ctx.ReadResource("stackit:index/publicIpAssociate:PublicIpAssociate", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering PublicIpAssociate resources. +type publicIpAssociateState struct { + // The IP address. + Ip *string `pulumi:"ip"` + // The ID of the network interface (or virtual IP) to which the public IP should be attached to. + NetworkInterfaceId *string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId *string `pulumi:"projectId"` + // The public IP ID. + PublicIpId *string `pulumi:"publicIpId"` +} + +type PublicIpAssociateState struct { + // The IP address. + Ip pulumi.StringPtrInput + // The ID of the network interface (or virtual IP) to which the public IP should be attached to. + NetworkInterfaceId pulumi.StringPtrInput + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringPtrInput + // The public IP ID. + PublicIpId pulumi.StringPtrInput +} + +func (PublicIpAssociateState) ElementType() reflect.Type { + return reflect.TypeOf((*publicIpAssociateState)(nil)).Elem() +} + +type publicIpAssociateArgs struct { + // The ID of the network interface (or virtual IP) to which the public IP should be attached to. + NetworkInterfaceId string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the public IP is associated. + ProjectId string `pulumi:"projectId"` + // The public IP ID. + PublicIpId string `pulumi:"publicIpId"` +} + +// The set of arguments for constructing a PublicIpAssociate resource. +type PublicIpAssociateArgs struct { + // The ID of the network interface (or virtual IP) to which the public IP should be attached to. + NetworkInterfaceId pulumi.StringInput + // STACKIT project ID to which the public IP is associated. + ProjectId pulumi.StringInput + // The public IP ID. + PublicIpId pulumi.StringInput +} + +func (PublicIpAssociateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*publicIpAssociateArgs)(nil)).Elem() +} + +type PublicIpAssociateInput interface { + pulumi.Input + + ToPublicIpAssociateOutput() PublicIpAssociateOutput + ToPublicIpAssociateOutputWithContext(ctx context.Context) PublicIpAssociateOutput +} + +func (*PublicIpAssociate) ElementType() reflect.Type { + return reflect.TypeOf((**PublicIpAssociate)(nil)).Elem() +} + +func (i *PublicIpAssociate) ToPublicIpAssociateOutput() PublicIpAssociateOutput { + return i.ToPublicIpAssociateOutputWithContext(context.Background()) +} + +func (i *PublicIpAssociate) ToPublicIpAssociateOutputWithContext(ctx context.Context) PublicIpAssociateOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpAssociateOutput) +} + +// PublicIpAssociateArrayInput is an input type that accepts PublicIpAssociateArray and PublicIpAssociateArrayOutput values. +// You can construct a concrete instance of `PublicIpAssociateArrayInput` via: +// +// PublicIpAssociateArray{ PublicIpAssociateArgs{...} } +type PublicIpAssociateArrayInput interface { + pulumi.Input + + ToPublicIpAssociateArrayOutput() PublicIpAssociateArrayOutput + ToPublicIpAssociateArrayOutputWithContext(context.Context) PublicIpAssociateArrayOutput +} + +type PublicIpAssociateArray []PublicIpAssociateInput + +func (PublicIpAssociateArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PublicIpAssociate)(nil)).Elem() +} + +func (i PublicIpAssociateArray) ToPublicIpAssociateArrayOutput() PublicIpAssociateArrayOutput { + return i.ToPublicIpAssociateArrayOutputWithContext(context.Background()) +} + +func (i PublicIpAssociateArray) ToPublicIpAssociateArrayOutputWithContext(ctx context.Context) PublicIpAssociateArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpAssociateArrayOutput) +} + +// PublicIpAssociateMapInput is an input type that accepts PublicIpAssociateMap and PublicIpAssociateMapOutput values. +// You can construct a concrete instance of `PublicIpAssociateMapInput` via: +// +// PublicIpAssociateMap{ "key": PublicIpAssociateArgs{...} } +type PublicIpAssociateMapInput interface { + pulumi.Input + + ToPublicIpAssociateMapOutput() PublicIpAssociateMapOutput + ToPublicIpAssociateMapOutputWithContext(context.Context) PublicIpAssociateMapOutput +} + +type PublicIpAssociateMap map[string]PublicIpAssociateInput + +func (PublicIpAssociateMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PublicIpAssociate)(nil)).Elem() +} + +func (i PublicIpAssociateMap) ToPublicIpAssociateMapOutput() PublicIpAssociateMapOutput { + return i.ToPublicIpAssociateMapOutputWithContext(context.Background()) +} + +func (i PublicIpAssociateMap) ToPublicIpAssociateMapOutputWithContext(ctx context.Context) PublicIpAssociateMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(PublicIpAssociateMapOutput) +} + +type PublicIpAssociateOutput struct{ *pulumi.OutputState } + +func (PublicIpAssociateOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PublicIpAssociate)(nil)).Elem() +} + +func (o PublicIpAssociateOutput) ToPublicIpAssociateOutput() PublicIpAssociateOutput { + return o +} + +func (o PublicIpAssociateOutput) ToPublicIpAssociateOutputWithContext(ctx context.Context) PublicIpAssociateOutput { + return o +} + +// The IP address. +func (o PublicIpAssociateOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIpAssociate) pulumi.StringOutput { return v.Ip }).(pulumi.StringOutput) +} + +// The ID of the network interface (or virtual IP) to which the public IP should be attached to. +func (o PublicIpAssociateOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIpAssociate) pulumi.StringOutput { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the public IP is associated. +func (o PublicIpAssociateOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIpAssociate) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The public IP ID. +func (o PublicIpAssociateOutput) PublicIpId() pulumi.StringOutput { + return o.ApplyT(func(v *PublicIpAssociate) pulumi.StringOutput { return v.PublicIpId }).(pulumi.StringOutput) +} + +type PublicIpAssociateArrayOutput struct{ *pulumi.OutputState } + +func (PublicIpAssociateArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*PublicIpAssociate)(nil)).Elem() +} + +func (o PublicIpAssociateArrayOutput) ToPublicIpAssociateArrayOutput() PublicIpAssociateArrayOutput { + return o +} + +func (o PublicIpAssociateArrayOutput) ToPublicIpAssociateArrayOutputWithContext(ctx context.Context) PublicIpAssociateArrayOutput { + return o +} + +func (o PublicIpAssociateArrayOutput) Index(i pulumi.IntInput) PublicIpAssociateOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *PublicIpAssociate { + return vs[0].([]*PublicIpAssociate)[vs[1].(int)] + }).(PublicIpAssociateOutput) +} + +type PublicIpAssociateMapOutput struct{ *pulumi.OutputState } + +func (PublicIpAssociateMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*PublicIpAssociate)(nil)).Elem() +} + +func (o PublicIpAssociateMapOutput) ToPublicIpAssociateMapOutput() PublicIpAssociateMapOutput { + return o +} + +func (o PublicIpAssociateMapOutput) ToPublicIpAssociateMapOutputWithContext(ctx context.Context) PublicIpAssociateMapOutput { + return o +} + +func (o PublicIpAssociateMapOutput) MapIndex(k pulumi.StringInput) PublicIpAssociateOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *PublicIpAssociate { + return vs[0].(map[string]*PublicIpAssociate)[vs[1].(string)] + }).(PublicIpAssociateOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpAssociateInput)(nil)).Elem(), &PublicIpAssociate{}) + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpAssociateArrayInput)(nil)).Elem(), PublicIpAssociateArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*PublicIpAssociateMapInput)(nil)).Elem(), PublicIpAssociateMap{}) + pulumi.RegisterOutputType(PublicIpAssociateOutput{}) + pulumi.RegisterOutputType(PublicIpAssociateArrayOutput{}) + pulumi.RegisterOutputType(PublicIpAssociateMapOutput{}) +} diff --git a/sdk/go/stackit/pulumi-plugin.json b/sdk/go/stackit/pulumi-plugin.json new file mode 100644 index 0000000..60d9f21 --- /dev/null +++ b/sdk/go/stackit/pulumi-plugin.json @@ -0,0 +1,5 @@ +{ + "resource": true, + "name": "stackit", + "server": "github://api.github.com/stackitcloud/pulumi-stackit" +} diff --git a/sdk/go/stackit/pulumiTypes.go b/sdk/go/stackit/pulumiTypes.go new file mode 100644 index 0000000..e97d01b --- /dev/null +++ b/sdk/go/stackit/pulumiTypes.go @@ -0,0 +1,17081 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +var _ = internal.GetEnvOrDefault + +type CdnDistributionConfig struct { + // The configured backend for the distribution + Backend CdnDistributionConfigBackend `pulumi:"backend"` + // The configured regions where content will be hosted + Regions []string `pulumi:"regions"` +} + +// CdnDistributionConfigInput is an input type that accepts CdnDistributionConfigArgs and CdnDistributionConfigOutput values. +// You can construct a concrete instance of `CdnDistributionConfigInput` via: +// +// CdnDistributionConfigArgs{...} +type CdnDistributionConfigInput interface { + pulumi.Input + + ToCdnDistributionConfigOutput() CdnDistributionConfigOutput + ToCdnDistributionConfigOutputWithContext(context.Context) CdnDistributionConfigOutput +} + +type CdnDistributionConfigArgs struct { + // The configured backend for the distribution + Backend CdnDistributionConfigBackendInput `pulumi:"backend"` + // The configured regions where content will be hosted + Regions pulumi.StringArrayInput `pulumi:"regions"` +} + +func (CdnDistributionConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionConfig)(nil)).Elem() +} + +func (i CdnDistributionConfigArgs) ToCdnDistributionConfigOutput() CdnDistributionConfigOutput { + return i.ToCdnDistributionConfigOutputWithContext(context.Background()) +} + +func (i CdnDistributionConfigArgs) ToCdnDistributionConfigOutputWithContext(ctx context.Context) CdnDistributionConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigOutput) +} + +func (i CdnDistributionConfigArgs) ToCdnDistributionConfigPtrOutput() CdnDistributionConfigPtrOutput { + return i.ToCdnDistributionConfigPtrOutputWithContext(context.Background()) +} + +func (i CdnDistributionConfigArgs) ToCdnDistributionConfigPtrOutputWithContext(ctx context.Context) CdnDistributionConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigOutput).ToCdnDistributionConfigPtrOutputWithContext(ctx) +} + +// CdnDistributionConfigPtrInput is an input type that accepts CdnDistributionConfigArgs, CdnDistributionConfigPtr and CdnDistributionConfigPtrOutput values. +// You can construct a concrete instance of `CdnDistributionConfigPtrInput` via: +// +// CdnDistributionConfigArgs{...} +// +// or: +// +// nil +type CdnDistributionConfigPtrInput interface { + pulumi.Input + + ToCdnDistributionConfigPtrOutput() CdnDistributionConfigPtrOutput + ToCdnDistributionConfigPtrOutputWithContext(context.Context) CdnDistributionConfigPtrOutput +} + +type cdnDistributionConfigPtrType CdnDistributionConfigArgs + +func CdnDistributionConfigPtr(v *CdnDistributionConfigArgs) CdnDistributionConfigPtrInput { + return (*cdnDistributionConfigPtrType)(v) +} + +func (*cdnDistributionConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistributionConfig)(nil)).Elem() +} + +func (i *cdnDistributionConfigPtrType) ToCdnDistributionConfigPtrOutput() CdnDistributionConfigPtrOutput { + return i.ToCdnDistributionConfigPtrOutputWithContext(context.Background()) +} + +func (i *cdnDistributionConfigPtrType) ToCdnDistributionConfigPtrOutputWithContext(ctx context.Context) CdnDistributionConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigPtrOutput) +} + +type CdnDistributionConfigOutput struct{ *pulumi.OutputState } + +func (CdnDistributionConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionConfig)(nil)).Elem() +} + +func (o CdnDistributionConfigOutput) ToCdnDistributionConfigOutput() CdnDistributionConfigOutput { + return o +} + +func (o CdnDistributionConfigOutput) ToCdnDistributionConfigOutputWithContext(ctx context.Context) CdnDistributionConfigOutput { + return o +} + +func (o CdnDistributionConfigOutput) ToCdnDistributionConfigPtrOutput() CdnDistributionConfigPtrOutput { + return o.ToCdnDistributionConfigPtrOutputWithContext(context.Background()) +} + +func (o CdnDistributionConfigOutput) ToCdnDistributionConfigPtrOutputWithContext(ctx context.Context) CdnDistributionConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v CdnDistributionConfig) *CdnDistributionConfig { + return &v + }).(CdnDistributionConfigPtrOutput) +} + +// The configured backend for the distribution +func (o CdnDistributionConfigOutput) Backend() CdnDistributionConfigBackendOutput { + return o.ApplyT(func(v CdnDistributionConfig) CdnDistributionConfigBackend { return v.Backend }).(CdnDistributionConfigBackendOutput) +} + +// The configured regions where content will be hosted +func (o CdnDistributionConfigOutput) Regions() pulumi.StringArrayOutput { + return o.ApplyT(func(v CdnDistributionConfig) []string { return v.Regions }).(pulumi.StringArrayOutput) +} + +type CdnDistributionConfigPtrOutput struct{ *pulumi.OutputState } + +func (CdnDistributionConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistributionConfig)(nil)).Elem() +} + +func (o CdnDistributionConfigPtrOutput) ToCdnDistributionConfigPtrOutput() CdnDistributionConfigPtrOutput { + return o +} + +func (o CdnDistributionConfigPtrOutput) ToCdnDistributionConfigPtrOutputWithContext(ctx context.Context) CdnDistributionConfigPtrOutput { + return o +} + +func (o CdnDistributionConfigPtrOutput) Elem() CdnDistributionConfigOutput { + return o.ApplyT(func(v *CdnDistributionConfig) CdnDistributionConfig { + if v != nil { + return *v + } + var ret CdnDistributionConfig + return ret + }).(CdnDistributionConfigOutput) +} + +// The configured backend for the distribution +func (o CdnDistributionConfigPtrOutput) Backend() CdnDistributionConfigBackendPtrOutput { + return o.ApplyT(func(v *CdnDistributionConfig) *CdnDistributionConfigBackend { + if v == nil { + return nil + } + return &v.Backend + }).(CdnDistributionConfigBackendPtrOutput) +} + +// The configured regions where content will be hosted +func (o CdnDistributionConfigPtrOutput) Regions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *CdnDistributionConfig) []string { + if v == nil { + return nil + } + return v.Regions + }).(pulumi.StringArrayOutput) +} + +type CdnDistributionConfigBackend struct { + // The configured origin request headers for the backend + OriginRequestHeaders map[string]string `pulumi:"originRequestHeaders"` + // The configured backend type for the distribution + OriginUrl string `pulumi:"originUrl"` + // The configured backend type. Supported values are: `http`. + Type string `pulumi:"type"` +} + +// CdnDistributionConfigBackendInput is an input type that accepts CdnDistributionConfigBackendArgs and CdnDistributionConfigBackendOutput values. +// You can construct a concrete instance of `CdnDistributionConfigBackendInput` via: +// +// CdnDistributionConfigBackendArgs{...} +type CdnDistributionConfigBackendInput interface { + pulumi.Input + + ToCdnDistributionConfigBackendOutput() CdnDistributionConfigBackendOutput + ToCdnDistributionConfigBackendOutputWithContext(context.Context) CdnDistributionConfigBackendOutput +} + +type CdnDistributionConfigBackendArgs struct { + // The configured origin request headers for the backend + OriginRequestHeaders pulumi.StringMapInput `pulumi:"originRequestHeaders"` + // The configured backend type for the distribution + OriginUrl pulumi.StringInput `pulumi:"originUrl"` + // The configured backend type. Supported values are: `http`. + Type pulumi.StringInput `pulumi:"type"` +} + +func (CdnDistributionConfigBackendArgs) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionConfigBackend)(nil)).Elem() +} + +func (i CdnDistributionConfigBackendArgs) ToCdnDistributionConfigBackendOutput() CdnDistributionConfigBackendOutput { + return i.ToCdnDistributionConfigBackendOutputWithContext(context.Background()) +} + +func (i CdnDistributionConfigBackendArgs) ToCdnDistributionConfigBackendOutputWithContext(ctx context.Context) CdnDistributionConfigBackendOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigBackendOutput) +} + +func (i CdnDistributionConfigBackendArgs) ToCdnDistributionConfigBackendPtrOutput() CdnDistributionConfigBackendPtrOutput { + return i.ToCdnDistributionConfigBackendPtrOutputWithContext(context.Background()) +} + +func (i CdnDistributionConfigBackendArgs) ToCdnDistributionConfigBackendPtrOutputWithContext(ctx context.Context) CdnDistributionConfigBackendPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigBackendOutput).ToCdnDistributionConfigBackendPtrOutputWithContext(ctx) +} + +// CdnDistributionConfigBackendPtrInput is an input type that accepts CdnDistributionConfigBackendArgs, CdnDistributionConfigBackendPtr and CdnDistributionConfigBackendPtrOutput values. +// You can construct a concrete instance of `CdnDistributionConfigBackendPtrInput` via: +// +// CdnDistributionConfigBackendArgs{...} +// +// or: +// +// nil +type CdnDistributionConfigBackendPtrInput interface { + pulumi.Input + + ToCdnDistributionConfigBackendPtrOutput() CdnDistributionConfigBackendPtrOutput + ToCdnDistributionConfigBackendPtrOutputWithContext(context.Context) CdnDistributionConfigBackendPtrOutput +} + +type cdnDistributionConfigBackendPtrType CdnDistributionConfigBackendArgs + +func CdnDistributionConfigBackendPtr(v *CdnDistributionConfigBackendArgs) CdnDistributionConfigBackendPtrInput { + return (*cdnDistributionConfigBackendPtrType)(v) +} + +func (*cdnDistributionConfigBackendPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistributionConfigBackend)(nil)).Elem() +} + +func (i *cdnDistributionConfigBackendPtrType) ToCdnDistributionConfigBackendPtrOutput() CdnDistributionConfigBackendPtrOutput { + return i.ToCdnDistributionConfigBackendPtrOutputWithContext(context.Background()) +} + +func (i *cdnDistributionConfigBackendPtrType) ToCdnDistributionConfigBackendPtrOutputWithContext(ctx context.Context) CdnDistributionConfigBackendPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionConfigBackendPtrOutput) +} + +type CdnDistributionConfigBackendOutput struct{ *pulumi.OutputState } + +func (CdnDistributionConfigBackendOutput) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionConfigBackend)(nil)).Elem() +} + +func (o CdnDistributionConfigBackendOutput) ToCdnDistributionConfigBackendOutput() CdnDistributionConfigBackendOutput { + return o +} + +func (o CdnDistributionConfigBackendOutput) ToCdnDistributionConfigBackendOutputWithContext(ctx context.Context) CdnDistributionConfigBackendOutput { + return o +} + +func (o CdnDistributionConfigBackendOutput) ToCdnDistributionConfigBackendPtrOutput() CdnDistributionConfigBackendPtrOutput { + return o.ToCdnDistributionConfigBackendPtrOutputWithContext(context.Background()) +} + +func (o CdnDistributionConfigBackendOutput) ToCdnDistributionConfigBackendPtrOutputWithContext(ctx context.Context) CdnDistributionConfigBackendPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v CdnDistributionConfigBackend) *CdnDistributionConfigBackend { + return &v + }).(CdnDistributionConfigBackendPtrOutput) +} + +// The configured origin request headers for the backend +func (o CdnDistributionConfigBackendOutput) OriginRequestHeaders() pulumi.StringMapOutput { + return o.ApplyT(func(v CdnDistributionConfigBackend) map[string]string { return v.OriginRequestHeaders }).(pulumi.StringMapOutput) +} + +// The configured backend type for the distribution +func (o CdnDistributionConfigBackendOutput) OriginUrl() pulumi.StringOutput { + return o.ApplyT(func(v CdnDistributionConfigBackend) string { return v.OriginUrl }).(pulumi.StringOutput) +} + +// The configured backend type. Supported values are: `http`. +func (o CdnDistributionConfigBackendOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v CdnDistributionConfigBackend) string { return v.Type }).(pulumi.StringOutput) +} + +type CdnDistributionConfigBackendPtrOutput struct{ *pulumi.OutputState } + +func (CdnDistributionConfigBackendPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CdnDistributionConfigBackend)(nil)).Elem() +} + +func (o CdnDistributionConfigBackendPtrOutput) ToCdnDistributionConfigBackendPtrOutput() CdnDistributionConfigBackendPtrOutput { + return o +} + +func (o CdnDistributionConfigBackendPtrOutput) ToCdnDistributionConfigBackendPtrOutputWithContext(ctx context.Context) CdnDistributionConfigBackendPtrOutput { + return o +} + +func (o CdnDistributionConfigBackendPtrOutput) Elem() CdnDistributionConfigBackendOutput { + return o.ApplyT(func(v *CdnDistributionConfigBackend) CdnDistributionConfigBackend { + if v != nil { + return *v + } + var ret CdnDistributionConfigBackend + return ret + }).(CdnDistributionConfigBackendOutput) +} + +// The configured origin request headers for the backend +func (o CdnDistributionConfigBackendPtrOutput) OriginRequestHeaders() pulumi.StringMapOutput { + return o.ApplyT(func(v *CdnDistributionConfigBackend) map[string]string { + if v == nil { + return nil + } + return v.OriginRequestHeaders + }).(pulumi.StringMapOutput) +} + +// The configured backend type for the distribution +func (o CdnDistributionConfigBackendPtrOutput) OriginUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CdnDistributionConfigBackend) *string { + if v == nil { + return nil + } + return &v.OriginUrl + }).(pulumi.StringPtrOutput) +} + +// The configured backend type. Supported values are: `http`. +func (o CdnDistributionConfigBackendPtrOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CdnDistributionConfigBackend) *string { + if v == nil { + return nil + } + return &v.Type + }).(pulumi.StringPtrOutput) +} + +type CdnDistributionDomain struct { + // List of domain errors + Errors []string `pulumi:"errors"` + // The name of the domain + Name *string `pulumi:"name"` + // The status of the domain + Status *string `pulumi:"status"` + // The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + Type *string `pulumi:"type"` +} + +// CdnDistributionDomainInput is an input type that accepts CdnDistributionDomainArgs and CdnDistributionDomainOutput values. +// You can construct a concrete instance of `CdnDistributionDomainInput` via: +// +// CdnDistributionDomainArgs{...} +type CdnDistributionDomainInput interface { + pulumi.Input + + ToCdnDistributionDomainOutput() CdnDistributionDomainOutput + ToCdnDistributionDomainOutputWithContext(context.Context) CdnDistributionDomainOutput +} + +type CdnDistributionDomainArgs struct { + // List of domain errors + Errors pulumi.StringArrayInput `pulumi:"errors"` + // The name of the domain + Name pulumi.StringPtrInput `pulumi:"name"` + // The status of the domain + Status pulumi.StringPtrInput `pulumi:"status"` + // The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + Type pulumi.StringPtrInput `pulumi:"type"` +} + +func (CdnDistributionDomainArgs) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionDomain)(nil)).Elem() +} + +func (i CdnDistributionDomainArgs) ToCdnDistributionDomainOutput() CdnDistributionDomainOutput { + return i.ToCdnDistributionDomainOutputWithContext(context.Background()) +} + +func (i CdnDistributionDomainArgs) ToCdnDistributionDomainOutputWithContext(ctx context.Context) CdnDistributionDomainOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionDomainOutput) +} + +// CdnDistributionDomainArrayInput is an input type that accepts CdnDistributionDomainArray and CdnDistributionDomainArrayOutput values. +// You can construct a concrete instance of `CdnDistributionDomainArrayInput` via: +// +// CdnDistributionDomainArray{ CdnDistributionDomainArgs{...} } +type CdnDistributionDomainArrayInput interface { + pulumi.Input + + ToCdnDistributionDomainArrayOutput() CdnDistributionDomainArrayOutput + ToCdnDistributionDomainArrayOutputWithContext(context.Context) CdnDistributionDomainArrayOutput +} + +type CdnDistributionDomainArray []CdnDistributionDomainInput + +func (CdnDistributionDomainArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]CdnDistributionDomain)(nil)).Elem() +} + +func (i CdnDistributionDomainArray) ToCdnDistributionDomainArrayOutput() CdnDistributionDomainArrayOutput { + return i.ToCdnDistributionDomainArrayOutputWithContext(context.Background()) +} + +func (i CdnDistributionDomainArray) ToCdnDistributionDomainArrayOutputWithContext(ctx context.Context) CdnDistributionDomainArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CdnDistributionDomainArrayOutput) +} + +type CdnDistributionDomainOutput struct{ *pulumi.OutputState } + +func (CdnDistributionDomainOutput) ElementType() reflect.Type { + return reflect.TypeOf((*CdnDistributionDomain)(nil)).Elem() +} + +func (o CdnDistributionDomainOutput) ToCdnDistributionDomainOutput() CdnDistributionDomainOutput { + return o +} + +func (o CdnDistributionDomainOutput) ToCdnDistributionDomainOutputWithContext(ctx context.Context) CdnDistributionDomainOutput { + return o +} + +// List of domain errors +func (o CdnDistributionDomainOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v CdnDistributionDomain) []string { return v.Errors }).(pulumi.StringArrayOutput) +} + +// The name of the domain +func (o CdnDistributionDomainOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v CdnDistributionDomain) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// The status of the domain +func (o CdnDistributionDomainOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v CdnDistributionDomain) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user +func (o CdnDistributionDomainOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v CdnDistributionDomain) *string { return v.Type }).(pulumi.StringPtrOutput) +} + +type CdnDistributionDomainArrayOutput struct{ *pulumi.OutputState } + +func (CdnDistributionDomainArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]CdnDistributionDomain)(nil)).Elem() +} + +func (o CdnDistributionDomainArrayOutput) ToCdnDistributionDomainArrayOutput() CdnDistributionDomainArrayOutput { + return o +} + +func (o CdnDistributionDomainArrayOutput) ToCdnDistributionDomainArrayOutputWithContext(ctx context.Context) CdnDistributionDomainArrayOutput { + return o +} + +func (o CdnDistributionDomainArrayOutput) Index(i pulumi.IntInput) CdnDistributionDomainOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) CdnDistributionDomain { + return vs[0].([]CdnDistributionDomain)[vs[1].(int)] + }).(CdnDistributionDomainOutput) +} + +type ImageChecksum struct { + // Algorithm for the checksum of the image data. + Algorithm *string `pulumi:"algorithm"` + // Hexdigest of the checksum of the image data. + Digest *string `pulumi:"digest"` +} + +// ImageChecksumInput is an input type that accepts ImageChecksumArgs and ImageChecksumOutput values. +// You can construct a concrete instance of `ImageChecksumInput` via: +// +// ImageChecksumArgs{...} +type ImageChecksumInput interface { + pulumi.Input + + ToImageChecksumOutput() ImageChecksumOutput + ToImageChecksumOutputWithContext(context.Context) ImageChecksumOutput +} + +type ImageChecksumArgs struct { + // Algorithm for the checksum of the image data. + Algorithm pulumi.StringPtrInput `pulumi:"algorithm"` + // Hexdigest of the checksum of the image data. + Digest pulumi.StringPtrInput `pulumi:"digest"` +} + +func (ImageChecksumArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ImageChecksum)(nil)).Elem() +} + +func (i ImageChecksumArgs) ToImageChecksumOutput() ImageChecksumOutput { + return i.ToImageChecksumOutputWithContext(context.Background()) +} + +func (i ImageChecksumArgs) ToImageChecksumOutputWithContext(ctx context.Context) ImageChecksumOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageChecksumOutput) +} + +func (i ImageChecksumArgs) ToImageChecksumPtrOutput() ImageChecksumPtrOutput { + return i.ToImageChecksumPtrOutputWithContext(context.Background()) +} + +func (i ImageChecksumArgs) ToImageChecksumPtrOutputWithContext(ctx context.Context) ImageChecksumPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageChecksumOutput).ToImageChecksumPtrOutputWithContext(ctx) +} + +// ImageChecksumPtrInput is an input type that accepts ImageChecksumArgs, ImageChecksumPtr and ImageChecksumPtrOutput values. +// You can construct a concrete instance of `ImageChecksumPtrInput` via: +// +// ImageChecksumArgs{...} +// +// or: +// +// nil +type ImageChecksumPtrInput interface { + pulumi.Input + + ToImageChecksumPtrOutput() ImageChecksumPtrOutput + ToImageChecksumPtrOutputWithContext(context.Context) ImageChecksumPtrOutput +} + +type imageChecksumPtrType ImageChecksumArgs + +func ImageChecksumPtr(v *ImageChecksumArgs) ImageChecksumPtrInput { + return (*imageChecksumPtrType)(v) +} + +func (*imageChecksumPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ImageChecksum)(nil)).Elem() +} + +func (i *imageChecksumPtrType) ToImageChecksumPtrOutput() ImageChecksumPtrOutput { + return i.ToImageChecksumPtrOutputWithContext(context.Background()) +} + +func (i *imageChecksumPtrType) ToImageChecksumPtrOutputWithContext(ctx context.Context) ImageChecksumPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageChecksumPtrOutput) +} + +type ImageChecksumOutput struct{ *pulumi.OutputState } + +func (ImageChecksumOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ImageChecksum)(nil)).Elem() +} + +func (o ImageChecksumOutput) ToImageChecksumOutput() ImageChecksumOutput { + return o +} + +func (o ImageChecksumOutput) ToImageChecksumOutputWithContext(ctx context.Context) ImageChecksumOutput { + return o +} + +func (o ImageChecksumOutput) ToImageChecksumPtrOutput() ImageChecksumPtrOutput { + return o.ToImageChecksumPtrOutputWithContext(context.Background()) +} + +func (o ImageChecksumOutput) ToImageChecksumPtrOutputWithContext(ctx context.Context) ImageChecksumPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ImageChecksum) *ImageChecksum { + return &v + }).(ImageChecksumPtrOutput) +} + +// Algorithm for the checksum of the image data. +func (o ImageChecksumOutput) Algorithm() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageChecksum) *string { return v.Algorithm }).(pulumi.StringPtrOutput) +} + +// Hexdigest of the checksum of the image data. +func (o ImageChecksumOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageChecksum) *string { return v.Digest }).(pulumi.StringPtrOutput) +} + +type ImageChecksumPtrOutput struct{ *pulumi.OutputState } + +func (ImageChecksumPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ImageChecksum)(nil)).Elem() +} + +func (o ImageChecksumPtrOutput) ToImageChecksumPtrOutput() ImageChecksumPtrOutput { + return o +} + +func (o ImageChecksumPtrOutput) ToImageChecksumPtrOutputWithContext(ctx context.Context) ImageChecksumPtrOutput { + return o +} + +func (o ImageChecksumPtrOutput) Elem() ImageChecksumOutput { + return o.ApplyT(func(v *ImageChecksum) ImageChecksum { + if v != nil { + return *v + } + var ret ImageChecksum + return ret + }).(ImageChecksumOutput) +} + +// Algorithm for the checksum of the image data. +func (o ImageChecksumPtrOutput) Algorithm() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageChecksum) *string { + if v == nil { + return nil + } + return v.Algorithm + }).(pulumi.StringPtrOutput) +} + +// Hexdigest of the checksum of the image data. +func (o ImageChecksumPtrOutput) Digest() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageChecksum) *string { + if v == nil { + return nil + } + return v.Digest + }).(pulumi.StringPtrOutput) +} + +type ImageConfig struct { + // Enables the BIOS bootmenu. + BootMenu *bool `pulumi:"bootMenu"` + // Sets CDROM bus controller type. + CdromBus *string `pulumi:"cdromBus"` + // Sets Disk bus controller type. + DiskBus *string `pulumi:"diskBus"` + // Sets virtual network interface model. + NicModel *string `pulumi:"nicModel"` + // Enables operating system specific optimizations. + OperatingSystem *string `pulumi:"operatingSystem"` + // Operating system distribution. + OperatingSystemDistro *string `pulumi:"operatingSystemDistro"` + // Version of the operating system. + OperatingSystemVersion *string `pulumi:"operatingSystemVersion"` + // Sets the device bus when the image is used as a rescue image. + RescueBus *string `pulumi:"rescueBus"` + // Sets the device when the image is used as a rescue image. + RescueDevice *string `pulumi:"rescueDevice"` + // Enables Secure Boot. + SecureBoot *bool `pulumi:"secureBoot"` + // Enables UEFI boot. + Uefi *bool `pulumi:"uefi"` + // Sets Graphic device model. + VideoModel *string `pulumi:"videoModel"` + // Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + VirtioScsi *bool `pulumi:"virtioScsi"` +} + +// ImageConfigInput is an input type that accepts ImageConfigArgs and ImageConfigOutput values. +// You can construct a concrete instance of `ImageConfigInput` via: +// +// ImageConfigArgs{...} +type ImageConfigInput interface { + pulumi.Input + + ToImageConfigOutput() ImageConfigOutput + ToImageConfigOutputWithContext(context.Context) ImageConfigOutput +} + +type ImageConfigArgs struct { + // Enables the BIOS bootmenu. + BootMenu pulumi.BoolPtrInput `pulumi:"bootMenu"` + // Sets CDROM bus controller type. + CdromBus pulumi.StringPtrInput `pulumi:"cdromBus"` + // Sets Disk bus controller type. + DiskBus pulumi.StringPtrInput `pulumi:"diskBus"` + // Sets virtual network interface model. + NicModel pulumi.StringPtrInput `pulumi:"nicModel"` + // Enables operating system specific optimizations. + OperatingSystem pulumi.StringPtrInput `pulumi:"operatingSystem"` + // Operating system distribution. + OperatingSystemDistro pulumi.StringPtrInput `pulumi:"operatingSystemDistro"` + // Version of the operating system. + OperatingSystemVersion pulumi.StringPtrInput `pulumi:"operatingSystemVersion"` + // Sets the device bus when the image is used as a rescue image. + RescueBus pulumi.StringPtrInput `pulumi:"rescueBus"` + // Sets the device when the image is used as a rescue image. + RescueDevice pulumi.StringPtrInput `pulumi:"rescueDevice"` + // Enables Secure Boot. + SecureBoot pulumi.BoolPtrInput `pulumi:"secureBoot"` + // Enables UEFI boot. + Uefi pulumi.BoolPtrInput `pulumi:"uefi"` + // Sets Graphic device model. + VideoModel pulumi.StringPtrInput `pulumi:"videoModel"` + // Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + VirtioScsi pulumi.BoolPtrInput `pulumi:"virtioScsi"` +} + +func (ImageConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ImageConfig)(nil)).Elem() +} + +func (i ImageConfigArgs) ToImageConfigOutput() ImageConfigOutput { + return i.ToImageConfigOutputWithContext(context.Background()) +} + +func (i ImageConfigArgs) ToImageConfigOutputWithContext(ctx context.Context) ImageConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageConfigOutput) +} + +func (i ImageConfigArgs) ToImageConfigPtrOutput() ImageConfigPtrOutput { + return i.ToImageConfigPtrOutputWithContext(context.Background()) +} + +func (i ImageConfigArgs) ToImageConfigPtrOutputWithContext(ctx context.Context) ImageConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageConfigOutput).ToImageConfigPtrOutputWithContext(ctx) +} + +// ImageConfigPtrInput is an input type that accepts ImageConfigArgs, ImageConfigPtr and ImageConfigPtrOutput values. +// You can construct a concrete instance of `ImageConfigPtrInput` via: +// +// ImageConfigArgs{...} +// +// or: +// +// nil +type ImageConfigPtrInput interface { + pulumi.Input + + ToImageConfigPtrOutput() ImageConfigPtrOutput + ToImageConfigPtrOutputWithContext(context.Context) ImageConfigPtrOutput +} + +type imageConfigPtrType ImageConfigArgs + +func ImageConfigPtr(v *ImageConfigArgs) ImageConfigPtrInput { + return (*imageConfigPtrType)(v) +} + +func (*imageConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ImageConfig)(nil)).Elem() +} + +func (i *imageConfigPtrType) ToImageConfigPtrOutput() ImageConfigPtrOutput { + return i.ToImageConfigPtrOutputWithContext(context.Background()) +} + +func (i *imageConfigPtrType) ToImageConfigPtrOutputWithContext(ctx context.Context) ImageConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ImageConfigPtrOutput) +} + +type ImageConfigOutput struct{ *pulumi.OutputState } + +func (ImageConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ImageConfig)(nil)).Elem() +} + +func (o ImageConfigOutput) ToImageConfigOutput() ImageConfigOutput { + return o +} + +func (o ImageConfigOutput) ToImageConfigOutputWithContext(ctx context.Context) ImageConfigOutput { + return o +} + +func (o ImageConfigOutput) ToImageConfigPtrOutput() ImageConfigPtrOutput { + return o.ToImageConfigPtrOutputWithContext(context.Background()) +} + +func (o ImageConfigOutput) ToImageConfigPtrOutputWithContext(ctx context.Context) ImageConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ImageConfig) *ImageConfig { + return &v + }).(ImageConfigPtrOutput) +} + +// Enables the BIOS bootmenu. +func (o ImageConfigOutput) BootMenu() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ImageConfig) *bool { return v.BootMenu }).(pulumi.BoolPtrOutput) +} + +// Sets CDROM bus controller type. +func (o ImageConfigOutput) CdromBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.CdromBus }).(pulumi.StringPtrOutput) +} + +// Sets Disk bus controller type. +func (o ImageConfigOutput) DiskBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.DiskBus }).(pulumi.StringPtrOutput) +} + +// Sets virtual network interface model. +func (o ImageConfigOutput) NicModel() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.NicModel }).(pulumi.StringPtrOutput) +} + +// Enables operating system specific optimizations. +func (o ImageConfigOutput) OperatingSystem() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.OperatingSystem }).(pulumi.StringPtrOutput) +} + +// Operating system distribution. +func (o ImageConfigOutput) OperatingSystemDistro() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.OperatingSystemDistro }).(pulumi.StringPtrOutput) +} + +// Version of the operating system. +func (o ImageConfigOutput) OperatingSystemVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.OperatingSystemVersion }).(pulumi.StringPtrOutput) +} + +// Sets the device bus when the image is used as a rescue image. +func (o ImageConfigOutput) RescueBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.RescueBus }).(pulumi.StringPtrOutput) +} + +// Sets the device when the image is used as a rescue image. +func (o ImageConfigOutput) RescueDevice() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.RescueDevice }).(pulumi.StringPtrOutput) +} + +// Enables Secure Boot. +func (o ImageConfigOutput) SecureBoot() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ImageConfig) *bool { return v.SecureBoot }).(pulumi.BoolPtrOutput) +} + +// Enables UEFI boot. +func (o ImageConfigOutput) Uefi() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ImageConfig) *bool { return v.Uefi }).(pulumi.BoolPtrOutput) +} + +// Sets Graphic device model. +func (o ImageConfigOutput) VideoModel() pulumi.StringPtrOutput { + return o.ApplyT(func(v ImageConfig) *string { return v.VideoModel }).(pulumi.StringPtrOutput) +} + +// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. +func (o ImageConfigOutput) VirtioScsi() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ImageConfig) *bool { return v.VirtioScsi }).(pulumi.BoolPtrOutput) +} + +type ImageConfigPtrOutput struct{ *pulumi.OutputState } + +func (ImageConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ImageConfig)(nil)).Elem() +} + +func (o ImageConfigPtrOutput) ToImageConfigPtrOutput() ImageConfigPtrOutput { + return o +} + +func (o ImageConfigPtrOutput) ToImageConfigPtrOutputWithContext(ctx context.Context) ImageConfigPtrOutput { + return o +} + +func (o ImageConfigPtrOutput) Elem() ImageConfigOutput { + return o.ApplyT(func(v *ImageConfig) ImageConfig { + if v != nil { + return *v + } + var ret ImageConfig + return ret + }).(ImageConfigOutput) +} + +// Enables the BIOS bootmenu. +func (o ImageConfigPtrOutput) BootMenu() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ImageConfig) *bool { + if v == nil { + return nil + } + return v.BootMenu + }).(pulumi.BoolPtrOutput) +} + +// Sets CDROM bus controller type. +func (o ImageConfigPtrOutput) CdromBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.CdromBus + }).(pulumi.StringPtrOutput) +} + +// Sets Disk bus controller type. +func (o ImageConfigPtrOutput) DiskBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.DiskBus + }).(pulumi.StringPtrOutput) +} + +// Sets virtual network interface model. +func (o ImageConfigPtrOutput) NicModel() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.NicModel + }).(pulumi.StringPtrOutput) +} + +// Enables operating system specific optimizations. +func (o ImageConfigPtrOutput) OperatingSystem() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.OperatingSystem + }).(pulumi.StringPtrOutput) +} + +// Operating system distribution. +func (o ImageConfigPtrOutput) OperatingSystemDistro() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.OperatingSystemDistro + }).(pulumi.StringPtrOutput) +} + +// Version of the operating system. +func (o ImageConfigPtrOutput) OperatingSystemVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.OperatingSystemVersion + }).(pulumi.StringPtrOutput) +} + +// Sets the device bus when the image is used as a rescue image. +func (o ImageConfigPtrOutput) RescueBus() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.RescueBus + }).(pulumi.StringPtrOutput) +} + +// Sets the device when the image is used as a rescue image. +func (o ImageConfigPtrOutput) RescueDevice() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.RescueDevice + }).(pulumi.StringPtrOutput) +} + +// Enables Secure Boot. +func (o ImageConfigPtrOutput) SecureBoot() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ImageConfig) *bool { + if v == nil { + return nil + } + return v.SecureBoot + }).(pulumi.BoolPtrOutput) +} + +// Enables UEFI boot. +func (o ImageConfigPtrOutput) Uefi() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ImageConfig) *bool { + if v == nil { + return nil + } + return v.Uefi + }).(pulumi.BoolPtrOutput) +} + +// Sets Graphic device model. +func (o ImageConfigPtrOutput) VideoModel() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ImageConfig) *string { + if v == nil { + return nil + } + return v.VideoModel + }).(pulumi.StringPtrOutput) +} + +// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. +func (o ImageConfigPtrOutput) VirtioScsi() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ImageConfig) *bool { + if v == nil { + return nil + } + return v.VirtioScsi + }).(pulumi.BoolPtrOutput) +} + +type LoadbalancerListener struct { + DisplayName *string `pulumi:"displayName"` + // Port number where we listen for traffic. + Port int `pulumi:"port"` + // Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + Protocol string `pulumi:"protocol"` + // A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + ServerNameIndicators []LoadbalancerListenerServerNameIndicator `pulumi:"serverNameIndicators"` + // Reference target pool by target pool name. + TargetPool string `pulumi:"targetPool"` +} + +// LoadbalancerListenerInput is an input type that accepts LoadbalancerListenerArgs and LoadbalancerListenerOutput values. +// You can construct a concrete instance of `LoadbalancerListenerInput` via: +// +// LoadbalancerListenerArgs{...} +type LoadbalancerListenerInput interface { + pulumi.Input + + ToLoadbalancerListenerOutput() LoadbalancerListenerOutput + ToLoadbalancerListenerOutputWithContext(context.Context) LoadbalancerListenerOutput +} + +type LoadbalancerListenerArgs struct { + DisplayName pulumi.StringPtrInput `pulumi:"displayName"` + // Port number where we listen for traffic. + Port pulumi.IntInput `pulumi:"port"` + // Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + Protocol pulumi.StringInput `pulumi:"protocol"` + // A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + ServerNameIndicators LoadbalancerListenerServerNameIndicatorArrayInput `pulumi:"serverNameIndicators"` + // Reference target pool by target pool name. + TargetPool pulumi.StringInput `pulumi:"targetPool"` +} + +func (LoadbalancerListenerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerListener)(nil)).Elem() +} + +func (i LoadbalancerListenerArgs) ToLoadbalancerListenerOutput() LoadbalancerListenerOutput { + return i.ToLoadbalancerListenerOutputWithContext(context.Background()) +} + +func (i LoadbalancerListenerArgs) ToLoadbalancerListenerOutputWithContext(ctx context.Context) LoadbalancerListenerOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerListenerOutput) +} + +// LoadbalancerListenerArrayInput is an input type that accepts LoadbalancerListenerArray and LoadbalancerListenerArrayOutput values. +// You can construct a concrete instance of `LoadbalancerListenerArrayInput` via: +// +// LoadbalancerListenerArray{ LoadbalancerListenerArgs{...} } +type LoadbalancerListenerArrayInput interface { + pulumi.Input + + ToLoadbalancerListenerArrayOutput() LoadbalancerListenerArrayOutput + ToLoadbalancerListenerArrayOutputWithContext(context.Context) LoadbalancerListenerArrayOutput +} + +type LoadbalancerListenerArray []LoadbalancerListenerInput + +func (LoadbalancerListenerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerListener)(nil)).Elem() +} + +func (i LoadbalancerListenerArray) ToLoadbalancerListenerArrayOutput() LoadbalancerListenerArrayOutput { + return i.ToLoadbalancerListenerArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerListenerArray) ToLoadbalancerListenerArrayOutputWithContext(ctx context.Context) LoadbalancerListenerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerListenerArrayOutput) +} + +type LoadbalancerListenerOutput struct{ *pulumi.OutputState } + +func (LoadbalancerListenerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerListener)(nil)).Elem() +} + +func (o LoadbalancerListenerOutput) ToLoadbalancerListenerOutput() LoadbalancerListenerOutput { + return o +} + +func (o LoadbalancerListenerOutput) ToLoadbalancerListenerOutputWithContext(ctx context.Context) LoadbalancerListenerOutput { + return o +} + +func (o LoadbalancerListenerOutput) DisplayName() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerListener) *string { return v.DisplayName }).(pulumi.StringPtrOutput) +} + +// Port number where we listen for traffic. +func (o LoadbalancerListenerOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v LoadbalancerListener) int { return v.Port }).(pulumi.IntOutput) +} + +// Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. +func (o LoadbalancerListenerOutput) Protocol() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerListener) string { return v.Protocol }).(pulumi.StringOutput) +} + +// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener +func (o LoadbalancerListenerOutput) ServerNameIndicators() LoadbalancerListenerServerNameIndicatorArrayOutput { + return o.ApplyT(func(v LoadbalancerListener) []LoadbalancerListenerServerNameIndicator { return v.ServerNameIndicators }).(LoadbalancerListenerServerNameIndicatorArrayOutput) +} + +// Reference target pool by target pool name. +func (o LoadbalancerListenerOutput) TargetPool() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerListener) string { return v.TargetPool }).(pulumi.StringOutput) +} + +type LoadbalancerListenerArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerListenerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerListener)(nil)).Elem() +} + +func (o LoadbalancerListenerArrayOutput) ToLoadbalancerListenerArrayOutput() LoadbalancerListenerArrayOutput { + return o +} + +func (o LoadbalancerListenerArrayOutput) ToLoadbalancerListenerArrayOutputWithContext(ctx context.Context) LoadbalancerListenerArrayOutput { + return o +} + +func (o LoadbalancerListenerArrayOutput) Index(i pulumi.IntInput) LoadbalancerListenerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadbalancerListener { + return vs[0].([]LoadbalancerListener)[vs[1].(int)] + }).(LoadbalancerListenerOutput) +} + +type LoadbalancerListenerServerNameIndicator struct { + // A domain name to match in order to pass TLS traffic to the target pool in the current listener + Name *string `pulumi:"name"` +} + +// LoadbalancerListenerServerNameIndicatorInput is an input type that accepts LoadbalancerListenerServerNameIndicatorArgs and LoadbalancerListenerServerNameIndicatorOutput values. +// You can construct a concrete instance of `LoadbalancerListenerServerNameIndicatorInput` via: +// +// LoadbalancerListenerServerNameIndicatorArgs{...} +type LoadbalancerListenerServerNameIndicatorInput interface { + pulumi.Input + + ToLoadbalancerListenerServerNameIndicatorOutput() LoadbalancerListenerServerNameIndicatorOutput + ToLoadbalancerListenerServerNameIndicatorOutputWithContext(context.Context) LoadbalancerListenerServerNameIndicatorOutput +} + +type LoadbalancerListenerServerNameIndicatorArgs struct { + // A domain name to match in order to pass TLS traffic to the target pool in the current listener + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (LoadbalancerListenerServerNameIndicatorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (i LoadbalancerListenerServerNameIndicatorArgs) ToLoadbalancerListenerServerNameIndicatorOutput() LoadbalancerListenerServerNameIndicatorOutput { + return i.ToLoadbalancerListenerServerNameIndicatorOutputWithContext(context.Background()) +} + +func (i LoadbalancerListenerServerNameIndicatorArgs) ToLoadbalancerListenerServerNameIndicatorOutputWithContext(ctx context.Context) LoadbalancerListenerServerNameIndicatorOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerListenerServerNameIndicatorOutput) +} + +// LoadbalancerListenerServerNameIndicatorArrayInput is an input type that accepts LoadbalancerListenerServerNameIndicatorArray and LoadbalancerListenerServerNameIndicatorArrayOutput values. +// You can construct a concrete instance of `LoadbalancerListenerServerNameIndicatorArrayInput` via: +// +// LoadbalancerListenerServerNameIndicatorArray{ LoadbalancerListenerServerNameIndicatorArgs{...} } +type LoadbalancerListenerServerNameIndicatorArrayInput interface { + pulumi.Input + + ToLoadbalancerListenerServerNameIndicatorArrayOutput() LoadbalancerListenerServerNameIndicatorArrayOutput + ToLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(context.Context) LoadbalancerListenerServerNameIndicatorArrayOutput +} + +type LoadbalancerListenerServerNameIndicatorArray []LoadbalancerListenerServerNameIndicatorInput + +func (LoadbalancerListenerServerNameIndicatorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (i LoadbalancerListenerServerNameIndicatorArray) ToLoadbalancerListenerServerNameIndicatorArrayOutput() LoadbalancerListenerServerNameIndicatorArrayOutput { + return i.ToLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerListenerServerNameIndicatorArray) ToLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(ctx context.Context) LoadbalancerListenerServerNameIndicatorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerListenerServerNameIndicatorArrayOutput) +} + +type LoadbalancerListenerServerNameIndicatorOutput struct{ *pulumi.OutputState } + +func (LoadbalancerListenerServerNameIndicatorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (o LoadbalancerListenerServerNameIndicatorOutput) ToLoadbalancerListenerServerNameIndicatorOutput() LoadbalancerListenerServerNameIndicatorOutput { + return o +} + +func (o LoadbalancerListenerServerNameIndicatorOutput) ToLoadbalancerListenerServerNameIndicatorOutputWithContext(ctx context.Context) LoadbalancerListenerServerNameIndicatorOutput { + return o +} + +// A domain name to match in order to pass TLS traffic to the target pool in the current listener +func (o LoadbalancerListenerServerNameIndicatorOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerListenerServerNameIndicator) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type LoadbalancerListenerServerNameIndicatorArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerListenerServerNameIndicatorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (o LoadbalancerListenerServerNameIndicatorArrayOutput) ToLoadbalancerListenerServerNameIndicatorArrayOutput() LoadbalancerListenerServerNameIndicatorArrayOutput { + return o +} + +func (o LoadbalancerListenerServerNameIndicatorArrayOutput) ToLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(ctx context.Context) LoadbalancerListenerServerNameIndicatorArrayOutput { + return o +} + +func (o LoadbalancerListenerServerNameIndicatorArrayOutput) Index(i pulumi.IntInput) LoadbalancerListenerServerNameIndicatorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadbalancerListenerServerNameIndicator { + return vs[0].([]LoadbalancerListenerServerNameIndicator)[vs[1].(int)] + }).(LoadbalancerListenerServerNameIndicatorOutput) +} + +type LoadbalancerNetwork struct { + // Openstack network ID. + NetworkId string `pulumi:"networkId"` + // The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + Role string `pulumi:"role"` +} + +// LoadbalancerNetworkInput is an input type that accepts LoadbalancerNetworkArgs and LoadbalancerNetworkOutput values. +// You can construct a concrete instance of `LoadbalancerNetworkInput` via: +// +// LoadbalancerNetworkArgs{...} +type LoadbalancerNetworkInput interface { + pulumi.Input + + ToLoadbalancerNetworkOutput() LoadbalancerNetworkOutput + ToLoadbalancerNetworkOutputWithContext(context.Context) LoadbalancerNetworkOutput +} + +type LoadbalancerNetworkArgs struct { + // Openstack network ID. + NetworkId pulumi.StringInput `pulumi:"networkId"` + // The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + Role pulumi.StringInput `pulumi:"role"` +} + +func (LoadbalancerNetworkArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerNetwork)(nil)).Elem() +} + +func (i LoadbalancerNetworkArgs) ToLoadbalancerNetworkOutput() LoadbalancerNetworkOutput { + return i.ToLoadbalancerNetworkOutputWithContext(context.Background()) +} + +func (i LoadbalancerNetworkArgs) ToLoadbalancerNetworkOutputWithContext(ctx context.Context) LoadbalancerNetworkOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerNetworkOutput) +} + +// LoadbalancerNetworkArrayInput is an input type that accepts LoadbalancerNetworkArray and LoadbalancerNetworkArrayOutput values. +// You can construct a concrete instance of `LoadbalancerNetworkArrayInput` via: +// +// LoadbalancerNetworkArray{ LoadbalancerNetworkArgs{...} } +type LoadbalancerNetworkArrayInput interface { + pulumi.Input + + ToLoadbalancerNetworkArrayOutput() LoadbalancerNetworkArrayOutput + ToLoadbalancerNetworkArrayOutputWithContext(context.Context) LoadbalancerNetworkArrayOutput +} + +type LoadbalancerNetworkArray []LoadbalancerNetworkInput + +func (LoadbalancerNetworkArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerNetwork)(nil)).Elem() +} + +func (i LoadbalancerNetworkArray) ToLoadbalancerNetworkArrayOutput() LoadbalancerNetworkArrayOutput { + return i.ToLoadbalancerNetworkArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerNetworkArray) ToLoadbalancerNetworkArrayOutputWithContext(ctx context.Context) LoadbalancerNetworkArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerNetworkArrayOutput) +} + +type LoadbalancerNetworkOutput struct{ *pulumi.OutputState } + +func (LoadbalancerNetworkOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerNetwork)(nil)).Elem() +} + +func (o LoadbalancerNetworkOutput) ToLoadbalancerNetworkOutput() LoadbalancerNetworkOutput { + return o +} + +func (o LoadbalancerNetworkOutput) ToLoadbalancerNetworkOutputWithContext(ctx context.Context) LoadbalancerNetworkOutput { + return o +} + +// Openstack network ID. +func (o LoadbalancerNetworkOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerNetwork) string { return v.NetworkId }).(pulumi.StringOutput) +} + +// The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. +func (o LoadbalancerNetworkOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerNetwork) string { return v.Role }).(pulumi.StringOutput) +} + +type LoadbalancerNetworkArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerNetworkArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerNetwork)(nil)).Elem() +} + +func (o LoadbalancerNetworkArrayOutput) ToLoadbalancerNetworkArrayOutput() LoadbalancerNetworkArrayOutput { + return o +} + +func (o LoadbalancerNetworkArrayOutput) ToLoadbalancerNetworkArrayOutputWithContext(ctx context.Context) LoadbalancerNetworkArrayOutput { + return o +} + +func (o LoadbalancerNetworkArrayOutput) Index(i pulumi.IntInput) LoadbalancerNetworkOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadbalancerNetwork { + return vs[0].([]LoadbalancerNetwork)[vs[1].(int)] + }).(LoadbalancerNetworkOutput) +} + +type LoadbalancerOptions struct { + // Load Balancer is accessible only from an IP address in this range. + Acls []string `pulumi:"acls"` + // We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + Observability *LoadbalancerOptionsObservability `pulumi:"observability"` + // If true, Load Balancer is accessible only via a private network IP address. + PrivateNetworkOnly *bool `pulumi:"privateNetworkOnly"` +} + +// LoadbalancerOptionsInput is an input type that accepts LoadbalancerOptionsArgs and LoadbalancerOptionsOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsInput` via: +// +// LoadbalancerOptionsArgs{...} +type LoadbalancerOptionsInput interface { + pulumi.Input + + ToLoadbalancerOptionsOutput() LoadbalancerOptionsOutput + ToLoadbalancerOptionsOutputWithContext(context.Context) LoadbalancerOptionsOutput +} + +type LoadbalancerOptionsArgs struct { + // Load Balancer is accessible only from an IP address in this range. + Acls pulumi.StringArrayInput `pulumi:"acls"` + // We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + Observability LoadbalancerOptionsObservabilityPtrInput `pulumi:"observability"` + // If true, Load Balancer is accessible only via a private network IP address. + PrivateNetworkOnly pulumi.BoolPtrInput `pulumi:"privateNetworkOnly"` +} + +func (LoadbalancerOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptions)(nil)).Elem() +} + +func (i LoadbalancerOptionsArgs) ToLoadbalancerOptionsOutput() LoadbalancerOptionsOutput { + return i.ToLoadbalancerOptionsOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsArgs) ToLoadbalancerOptionsOutputWithContext(ctx context.Context) LoadbalancerOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsOutput) +} + +func (i LoadbalancerOptionsArgs) ToLoadbalancerOptionsPtrOutput() LoadbalancerOptionsPtrOutput { + return i.ToLoadbalancerOptionsPtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsArgs) ToLoadbalancerOptionsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsOutput).ToLoadbalancerOptionsPtrOutputWithContext(ctx) +} + +// LoadbalancerOptionsPtrInput is an input type that accepts LoadbalancerOptionsArgs, LoadbalancerOptionsPtr and LoadbalancerOptionsPtrOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsPtrInput` via: +// +// LoadbalancerOptionsArgs{...} +// +// or: +// +// nil +type LoadbalancerOptionsPtrInput interface { + pulumi.Input + + ToLoadbalancerOptionsPtrOutput() LoadbalancerOptionsPtrOutput + ToLoadbalancerOptionsPtrOutputWithContext(context.Context) LoadbalancerOptionsPtrOutput +} + +type loadbalancerOptionsPtrType LoadbalancerOptionsArgs + +func LoadbalancerOptionsPtr(v *LoadbalancerOptionsArgs) LoadbalancerOptionsPtrInput { + return (*loadbalancerOptionsPtrType)(v) +} + +func (*loadbalancerOptionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptions)(nil)).Elem() +} + +func (i *loadbalancerOptionsPtrType) ToLoadbalancerOptionsPtrOutput() LoadbalancerOptionsPtrOutput { + return i.ToLoadbalancerOptionsPtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerOptionsPtrType) ToLoadbalancerOptionsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsPtrOutput) +} + +type LoadbalancerOptionsOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptions)(nil)).Elem() +} + +func (o LoadbalancerOptionsOutput) ToLoadbalancerOptionsOutput() LoadbalancerOptionsOutput { + return o +} + +func (o LoadbalancerOptionsOutput) ToLoadbalancerOptionsOutputWithContext(ctx context.Context) LoadbalancerOptionsOutput { + return o +} + +func (o LoadbalancerOptionsOutput) ToLoadbalancerOptionsPtrOutput() LoadbalancerOptionsPtrOutput { + return o.ToLoadbalancerOptionsPtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerOptionsOutput) ToLoadbalancerOptionsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerOptions) *LoadbalancerOptions { + return &v + }).(LoadbalancerOptionsPtrOutput) +} + +// Load Balancer is accessible only from an IP address in this range. +func (o LoadbalancerOptionsOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v LoadbalancerOptions) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +// We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. +func (o LoadbalancerOptionsOutput) Observability() LoadbalancerOptionsObservabilityPtrOutput { + return o.ApplyT(func(v LoadbalancerOptions) *LoadbalancerOptionsObservability { return v.Observability }).(LoadbalancerOptionsObservabilityPtrOutput) +} + +// If true, Load Balancer is accessible only via a private network IP address. +func (o LoadbalancerOptionsOutput) PrivateNetworkOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LoadbalancerOptions) *bool { return v.PrivateNetworkOnly }).(pulumi.BoolPtrOutput) +} + +type LoadbalancerOptionsPtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptions)(nil)).Elem() +} + +func (o LoadbalancerOptionsPtrOutput) ToLoadbalancerOptionsPtrOutput() LoadbalancerOptionsPtrOutput { + return o +} + +func (o LoadbalancerOptionsPtrOutput) ToLoadbalancerOptionsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsPtrOutput { + return o +} + +func (o LoadbalancerOptionsPtrOutput) Elem() LoadbalancerOptionsOutput { + return o.ApplyT(func(v *LoadbalancerOptions) LoadbalancerOptions { + if v != nil { + return *v + } + var ret LoadbalancerOptions + return ret + }).(LoadbalancerOptionsOutput) +} + +// Load Balancer is accessible only from an IP address in this range. +func (o LoadbalancerOptionsPtrOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *LoadbalancerOptions) []string { + if v == nil { + return nil + } + return v.Acls + }).(pulumi.StringArrayOutput) +} + +// We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. +func (o LoadbalancerOptionsPtrOutput) Observability() LoadbalancerOptionsObservabilityPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptions) *LoadbalancerOptionsObservability { + if v == nil { + return nil + } + return v.Observability + }).(LoadbalancerOptionsObservabilityPtrOutput) +} + +// If true, Load Balancer is accessible only via a private network IP address. +func (o LoadbalancerOptionsPtrOutput) PrivateNetworkOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptions) *bool { + if v == nil { + return nil + } + return v.PrivateNetworkOnly + }).(pulumi.BoolPtrOutput) +} + +type LoadbalancerOptionsObservability struct { + // Observability logs configuration. Not changeable after creation. + Logs *LoadbalancerOptionsObservabilityLogs `pulumi:"logs"` + // Observability metrics configuration. Not changeable after creation. + Metrics *LoadbalancerOptionsObservabilityMetrics `pulumi:"metrics"` +} + +// LoadbalancerOptionsObservabilityInput is an input type that accepts LoadbalancerOptionsObservabilityArgs and LoadbalancerOptionsObservabilityOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityInput` via: +// +// LoadbalancerOptionsObservabilityArgs{...} +type LoadbalancerOptionsObservabilityInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityOutput() LoadbalancerOptionsObservabilityOutput + ToLoadbalancerOptionsObservabilityOutputWithContext(context.Context) LoadbalancerOptionsObservabilityOutput +} + +type LoadbalancerOptionsObservabilityArgs struct { + // Observability logs configuration. Not changeable after creation. + Logs LoadbalancerOptionsObservabilityLogsPtrInput `pulumi:"logs"` + // Observability metrics configuration. Not changeable after creation. + Metrics LoadbalancerOptionsObservabilityMetricsPtrInput `pulumi:"metrics"` +} + +func (LoadbalancerOptionsObservabilityArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservability)(nil)).Elem() +} + +func (i LoadbalancerOptionsObservabilityArgs) ToLoadbalancerOptionsObservabilityOutput() LoadbalancerOptionsObservabilityOutput { + return i.ToLoadbalancerOptionsObservabilityOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityArgs) ToLoadbalancerOptionsObservabilityOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityOutput) +} + +func (i LoadbalancerOptionsObservabilityArgs) ToLoadbalancerOptionsObservabilityPtrOutput() LoadbalancerOptionsObservabilityPtrOutput { + return i.ToLoadbalancerOptionsObservabilityPtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityArgs) ToLoadbalancerOptionsObservabilityPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityOutput).ToLoadbalancerOptionsObservabilityPtrOutputWithContext(ctx) +} + +// LoadbalancerOptionsObservabilityPtrInput is an input type that accepts LoadbalancerOptionsObservabilityArgs, LoadbalancerOptionsObservabilityPtr and LoadbalancerOptionsObservabilityPtrOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityPtrInput` via: +// +// LoadbalancerOptionsObservabilityArgs{...} +// +// or: +// +// nil +type LoadbalancerOptionsObservabilityPtrInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityPtrOutput() LoadbalancerOptionsObservabilityPtrOutput + ToLoadbalancerOptionsObservabilityPtrOutputWithContext(context.Context) LoadbalancerOptionsObservabilityPtrOutput +} + +type loadbalancerOptionsObservabilityPtrType LoadbalancerOptionsObservabilityArgs + +func LoadbalancerOptionsObservabilityPtr(v *LoadbalancerOptionsObservabilityArgs) LoadbalancerOptionsObservabilityPtrInput { + return (*loadbalancerOptionsObservabilityPtrType)(v) +} + +func (*loadbalancerOptionsObservabilityPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservability)(nil)).Elem() +} + +func (i *loadbalancerOptionsObservabilityPtrType) ToLoadbalancerOptionsObservabilityPtrOutput() LoadbalancerOptionsObservabilityPtrOutput { + return i.ToLoadbalancerOptionsObservabilityPtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerOptionsObservabilityPtrType) ToLoadbalancerOptionsObservabilityPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityPtrOutput) +} + +type LoadbalancerOptionsObservabilityOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservability)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityOutput) ToLoadbalancerOptionsObservabilityOutput() LoadbalancerOptionsObservabilityOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityOutput) ToLoadbalancerOptionsObservabilityOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityOutput) ToLoadbalancerOptionsObservabilityPtrOutput() LoadbalancerOptionsObservabilityPtrOutput { + return o.ToLoadbalancerOptionsObservabilityPtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerOptionsObservabilityOutput) ToLoadbalancerOptionsObservabilityPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerOptionsObservability) *LoadbalancerOptionsObservability { + return &v + }).(LoadbalancerOptionsObservabilityPtrOutput) +} + +// Observability logs configuration. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityOutput) Logs() LoadbalancerOptionsObservabilityLogsPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservability) *LoadbalancerOptionsObservabilityLogs { return v.Logs }).(LoadbalancerOptionsObservabilityLogsPtrOutput) +} + +// Observability metrics configuration. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityOutput) Metrics() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservability) *LoadbalancerOptionsObservabilityMetrics { return v.Metrics }).(LoadbalancerOptionsObservabilityMetricsPtrOutput) +} + +type LoadbalancerOptionsObservabilityPtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservability)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityPtrOutput) ToLoadbalancerOptionsObservabilityPtrOutput() LoadbalancerOptionsObservabilityPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityPtrOutput) ToLoadbalancerOptionsObservabilityPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityPtrOutput) Elem() LoadbalancerOptionsObservabilityOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservability) LoadbalancerOptionsObservability { + if v != nil { + return *v + } + var ret LoadbalancerOptionsObservability + return ret + }).(LoadbalancerOptionsObservabilityOutput) +} + +// Observability logs configuration. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityPtrOutput) Logs() LoadbalancerOptionsObservabilityLogsPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservability) *LoadbalancerOptionsObservabilityLogs { + if v == nil { + return nil + } + return v.Logs + }).(LoadbalancerOptionsObservabilityLogsPtrOutput) +} + +// Observability metrics configuration. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityPtrOutput) Metrics() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservability) *LoadbalancerOptionsObservabilityMetrics { + if v == nil { + return nil + } + return v.Metrics + }).(LoadbalancerOptionsObservabilityMetricsPtrOutput) +} + +type LoadbalancerOptionsObservabilityLogs struct { + // Credentials reference for logs. Not changeable after creation. + CredentialsRef *string `pulumi:"credentialsRef"` + // Credentials reference for logs. Not changeable after creation. + PushUrl *string `pulumi:"pushUrl"` +} + +// LoadbalancerOptionsObservabilityLogsInput is an input type that accepts LoadbalancerOptionsObservabilityLogsArgs and LoadbalancerOptionsObservabilityLogsOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityLogsInput` via: +// +// LoadbalancerOptionsObservabilityLogsArgs{...} +type LoadbalancerOptionsObservabilityLogsInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityLogsOutput() LoadbalancerOptionsObservabilityLogsOutput + ToLoadbalancerOptionsObservabilityLogsOutputWithContext(context.Context) LoadbalancerOptionsObservabilityLogsOutput +} + +type LoadbalancerOptionsObservabilityLogsArgs struct { + // Credentials reference for logs. Not changeable after creation. + CredentialsRef pulumi.StringPtrInput `pulumi:"credentialsRef"` + // Credentials reference for logs. Not changeable after creation. + PushUrl pulumi.StringPtrInput `pulumi:"pushUrl"` +} + +func (LoadbalancerOptionsObservabilityLogsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (i LoadbalancerOptionsObservabilityLogsArgs) ToLoadbalancerOptionsObservabilityLogsOutput() LoadbalancerOptionsObservabilityLogsOutput { + return i.ToLoadbalancerOptionsObservabilityLogsOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityLogsArgs) ToLoadbalancerOptionsObservabilityLogsOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityLogsOutput) +} + +func (i LoadbalancerOptionsObservabilityLogsArgs) ToLoadbalancerOptionsObservabilityLogsPtrOutput() LoadbalancerOptionsObservabilityLogsPtrOutput { + return i.ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityLogsArgs) ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityLogsOutput).ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(ctx) +} + +// LoadbalancerOptionsObservabilityLogsPtrInput is an input type that accepts LoadbalancerOptionsObservabilityLogsArgs, LoadbalancerOptionsObservabilityLogsPtr and LoadbalancerOptionsObservabilityLogsPtrOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityLogsPtrInput` via: +// +// LoadbalancerOptionsObservabilityLogsArgs{...} +// +// or: +// +// nil +type LoadbalancerOptionsObservabilityLogsPtrInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityLogsPtrOutput() LoadbalancerOptionsObservabilityLogsPtrOutput + ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(context.Context) LoadbalancerOptionsObservabilityLogsPtrOutput +} + +type loadbalancerOptionsObservabilityLogsPtrType LoadbalancerOptionsObservabilityLogsArgs + +func LoadbalancerOptionsObservabilityLogsPtr(v *LoadbalancerOptionsObservabilityLogsArgs) LoadbalancerOptionsObservabilityLogsPtrInput { + return (*loadbalancerOptionsObservabilityLogsPtrType)(v) +} + +func (*loadbalancerOptionsObservabilityLogsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (i *loadbalancerOptionsObservabilityLogsPtrType) ToLoadbalancerOptionsObservabilityLogsPtrOutput() LoadbalancerOptionsObservabilityLogsPtrOutput { + return i.ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerOptionsObservabilityLogsPtrType) ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityLogsPtrOutput) +} + +type LoadbalancerOptionsObservabilityLogsOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityLogsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityLogsOutput) ToLoadbalancerOptionsObservabilityLogsOutput() LoadbalancerOptionsObservabilityLogsOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityLogsOutput) ToLoadbalancerOptionsObservabilityLogsOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityLogsOutput) ToLoadbalancerOptionsObservabilityLogsPtrOutput() LoadbalancerOptionsObservabilityLogsPtrOutput { + return o.ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerOptionsObservabilityLogsOutput) ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerOptionsObservabilityLogs) *LoadbalancerOptionsObservabilityLogs { + return &v + }).(LoadbalancerOptionsObservabilityLogsPtrOutput) +} + +// Credentials reference for logs. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityLogsOutput) CredentialsRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservabilityLogs) *string { return v.CredentialsRef }).(pulumi.StringPtrOutput) +} + +// Credentials reference for logs. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityLogsOutput) PushUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservabilityLogs) *string { return v.PushUrl }).(pulumi.StringPtrOutput) +} + +type LoadbalancerOptionsObservabilityLogsPtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityLogsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityLogsPtrOutput) ToLoadbalancerOptionsObservabilityLogsPtrOutput() LoadbalancerOptionsObservabilityLogsPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityLogsPtrOutput) ToLoadbalancerOptionsObservabilityLogsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityLogsPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityLogsPtrOutput) Elem() LoadbalancerOptionsObservabilityLogsOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityLogs) LoadbalancerOptionsObservabilityLogs { + if v != nil { + return *v + } + var ret LoadbalancerOptionsObservabilityLogs + return ret + }).(LoadbalancerOptionsObservabilityLogsOutput) +} + +// Credentials reference for logs. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityLogsPtrOutput) CredentialsRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityLogs) *string { + if v == nil { + return nil + } + return v.CredentialsRef + }).(pulumi.StringPtrOutput) +} + +// Credentials reference for logs. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityLogsPtrOutput) PushUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityLogs) *string { + if v == nil { + return nil + } + return v.PushUrl + }).(pulumi.StringPtrOutput) +} + +type LoadbalancerOptionsObservabilityMetrics struct { + // Credentials reference for metrics. Not changeable after creation. + CredentialsRef *string `pulumi:"credentialsRef"` + // Credentials reference for metrics. Not changeable after creation. + PushUrl *string `pulumi:"pushUrl"` +} + +// LoadbalancerOptionsObservabilityMetricsInput is an input type that accepts LoadbalancerOptionsObservabilityMetricsArgs and LoadbalancerOptionsObservabilityMetricsOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityMetricsInput` via: +// +// LoadbalancerOptionsObservabilityMetricsArgs{...} +type LoadbalancerOptionsObservabilityMetricsInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityMetricsOutput() LoadbalancerOptionsObservabilityMetricsOutput + ToLoadbalancerOptionsObservabilityMetricsOutputWithContext(context.Context) LoadbalancerOptionsObservabilityMetricsOutput +} + +type LoadbalancerOptionsObservabilityMetricsArgs struct { + // Credentials reference for metrics. Not changeable after creation. + CredentialsRef pulumi.StringPtrInput `pulumi:"credentialsRef"` + // Credentials reference for metrics. Not changeable after creation. + PushUrl pulumi.StringPtrInput `pulumi:"pushUrl"` +} + +func (LoadbalancerOptionsObservabilityMetricsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (i LoadbalancerOptionsObservabilityMetricsArgs) ToLoadbalancerOptionsObservabilityMetricsOutput() LoadbalancerOptionsObservabilityMetricsOutput { + return i.ToLoadbalancerOptionsObservabilityMetricsOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityMetricsArgs) ToLoadbalancerOptionsObservabilityMetricsOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityMetricsOutput) +} + +func (i LoadbalancerOptionsObservabilityMetricsArgs) ToLoadbalancerOptionsObservabilityMetricsPtrOutput() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return i.ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerOptionsObservabilityMetricsArgs) ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityMetricsOutput).ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(ctx) +} + +// LoadbalancerOptionsObservabilityMetricsPtrInput is an input type that accepts LoadbalancerOptionsObservabilityMetricsArgs, LoadbalancerOptionsObservabilityMetricsPtr and LoadbalancerOptionsObservabilityMetricsPtrOutput values. +// You can construct a concrete instance of `LoadbalancerOptionsObservabilityMetricsPtrInput` via: +// +// LoadbalancerOptionsObservabilityMetricsArgs{...} +// +// or: +// +// nil +type LoadbalancerOptionsObservabilityMetricsPtrInput interface { + pulumi.Input + + ToLoadbalancerOptionsObservabilityMetricsPtrOutput() LoadbalancerOptionsObservabilityMetricsPtrOutput + ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(context.Context) LoadbalancerOptionsObservabilityMetricsPtrOutput +} + +type loadbalancerOptionsObservabilityMetricsPtrType LoadbalancerOptionsObservabilityMetricsArgs + +func LoadbalancerOptionsObservabilityMetricsPtr(v *LoadbalancerOptionsObservabilityMetricsArgs) LoadbalancerOptionsObservabilityMetricsPtrInput { + return (*loadbalancerOptionsObservabilityMetricsPtrType)(v) +} + +func (*loadbalancerOptionsObservabilityMetricsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (i *loadbalancerOptionsObservabilityMetricsPtrType) ToLoadbalancerOptionsObservabilityMetricsPtrOutput() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return i.ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerOptionsObservabilityMetricsPtrType) ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerOptionsObservabilityMetricsPtrOutput) +} + +type LoadbalancerOptionsObservabilityMetricsOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityMetricsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityMetricsOutput) ToLoadbalancerOptionsObservabilityMetricsOutput() LoadbalancerOptionsObservabilityMetricsOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityMetricsOutput) ToLoadbalancerOptionsObservabilityMetricsOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityMetricsOutput) ToLoadbalancerOptionsObservabilityMetricsPtrOutput() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o.ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerOptionsObservabilityMetricsOutput) ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerOptionsObservabilityMetrics) *LoadbalancerOptionsObservabilityMetrics { + return &v + }).(LoadbalancerOptionsObservabilityMetricsPtrOutput) +} + +// Credentials reference for metrics. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityMetricsOutput) CredentialsRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservabilityMetrics) *string { return v.CredentialsRef }).(pulumi.StringPtrOutput) +} + +// Credentials reference for metrics. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityMetricsOutput) PushUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerOptionsObservabilityMetrics) *string { return v.PushUrl }).(pulumi.StringPtrOutput) +} + +type LoadbalancerOptionsObservabilityMetricsPtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerOptionsObservabilityMetricsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (o LoadbalancerOptionsObservabilityMetricsPtrOutput) ToLoadbalancerOptionsObservabilityMetricsPtrOutput() LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityMetricsPtrOutput) ToLoadbalancerOptionsObservabilityMetricsPtrOutputWithContext(ctx context.Context) LoadbalancerOptionsObservabilityMetricsPtrOutput { + return o +} + +func (o LoadbalancerOptionsObservabilityMetricsPtrOutput) Elem() LoadbalancerOptionsObservabilityMetricsOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityMetrics) LoadbalancerOptionsObservabilityMetrics { + if v != nil { + return *v + } + var ret LoadbalancerOptionsObservabilityMetrics + return ret + }).(LoadbalancerOptionsObservabilityMetricsOutput) +} + +// Credentials reference for metrics. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityMetricsPtrOutput) CredentialsRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityMetrics) *string { + if v == nil { + return nil + } + return v.CredentialsRef + }).(pulumi.StringPtrOutput) +} + +// Credentials reference for metrics. Not changeable after creation. +func (o LoadbalancerOptionsObservabilityMetricsPtrOutput) PushUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerOptionsObservabilityMetrics) *string { + if v == nil { + return nil + } + return v.PushUrl + }).(pulumi.StringPtrOutput) +} + +type LoadbalancerTargetPool struct { + ActiveHealthCheck *LoadbalancerTargetPoolActiveHealthCheck `pulumi:"activeHealthCheck"` + // Target pool name. + Name string `pulumi:"name"` + // Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + SessionPersistence *LoadbalancerTargetPoolSessionPersistence `pulumi:"sessionPersistence"` + // Identical port number where each target listens for traffic. + TargetPort int `pulumi:"targetPort"` + // List of all targets which will be used in the pool. Limited to 1000. + Targets []LoadbalancerTargetPoolTarget `pulumi:"targets"` +} + +// LoadbalancerTargetPoolInput is an input type that accepts LoadbalancerTargetPoolArgs and LoadbalancerTargetPoolOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolInput` via: +// +// LoadbalancerTargetPoolArgs{...} +type LoadbalancerTargetPoolInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolOutput() LoadbalancerTargetPoolOutput + ToLoadbalancerTargetPoolOutputWithContext(context.Context) LoadbalancerTargetPoolOutput +} + +type LoadbalancerTargetPoolArgs struct { + ActiveHealthCheck LoadbalancerTargetPoolActiveHealthCheckPtrInput `pulumi:"activeHealthCheck"` + // Target pool name. + Name pulumi.StringInput `pulumi:"name"` + // Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + SessionPersistence LoadbalancerTargetPoolSessionPersistencePtrInput `pulumi:"sessionPersistence"` + // Identical port number where each target listens for traffic. + TargetPort pulumi.IntInput `pulumi:"targetPort"` + // List of all targets which will be used in the pool. Limited to 1000. + Targets LoadbalancerTargetPoolTargetArrayInput `pulumi:"targets"` +} + +func (LoadbalancerTargetPoolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPool)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolArgs) ToLoadbalancerTargetPoolOutput() LoadbalancerTargetPoolOutput { + return i.ToLoadbalancerTargetPoolOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolArgs) ToLoadbalancerTargetPoolOutputWithContext(ctx context.Context) LoadbalancerTargetPoolOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolOutput) +} + +// LoadbalancerTargetPoolArrayInput is an input type that accepts LoadbalancerTargetPoolArray and LoadbalancerTargetPoolArrayOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolArrayInput` via: +// +// LoadbalancerTargetPoolArray{ LoadbalancerTargetPoolArgs{...} } +type LoadbalancerTargetPoolArrayInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolArrayOutput() LoadbalancerTargetPoolArrayOutput + ToLoadbalancerTargetPoolArrayOutputWithContext(context.Context) LoadbalancerTargetPoolArrayOutput +} + +type LoadbalancerTargetPoolArray []LoadbalancerTargetPoolInput + +func (LoadbalancerTargetPoolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerTargetPool)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolArray) ToLoadbalancerTargetPoolArrayOutput() LoadbalancerTargetPoolArrayOutput { + return i.ToLoadbalancerTargetPoolArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolArray) ToLoadbalancerTargetPoolArrayOutputWithContext(ctx context.Context) LoadbalancerTargetPoolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolArrayOutput) +} + +type LoadbalancerTargetPoolOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPool)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolOutput) ToLoadbalancerTargetPoolOutput() LoadbalancerTargetPoolOutput { + return o +} + +func (o LoadbalancerTargetPoolOutput) ToLoadbalancerTargetPoolOutputWithContext(ctx context.Context) LoadbalancerTargetPoolOutput { + return o +} + +func (o LoadbalancerTargetPoolOutput) ActiveHealthCheck() LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPool) *LoadbalancerTargetPoolActiveHealthCheck { return v.ActiveHealthCheck }).(LoadbalancerTargetPoolActiveHealthCheckPtrOutput) +} + +// Target pool name. +func (o LoadbalancerTargetPoolOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerTargetPool) string { return v.Name }).(pulumi.StringOutput) +} + +// Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. +func (o LoadbalancerTargetPoolOutput) SessionPersistence() LoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPool) *LoadbalancerTargetPoolSessionPersistence { return v.SessionPersistence }).(LoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +// Identical port number where each target listens for traffic. +func (o LoadbalancerTargetPoolOutput) TargetPort() pulumi.IntOutput { + return o.ApplyT(func(v LoadbalancerTargetPool) int { return v.TargetPort }).(pulumi.IntOutput) +} + +// List of all targets which will be used in the pool. Limited to 1000. +func (o LoadbalancerTargetPoolOutput) Targets() LoadbalancerTargetPoolTargetArrayOutput { + return o.ApplyT(func(v LoadbalancerTargetPool) []LoadbalancerTargetPoolTarget { return v.Targets }).(LoadbalancerTargetPoolTargetArrayOutput) +} + +type LoadbalancerTargetPoolArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerTargetPool)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolArrayOutput) ToLoadbalancerTargetPoolArrayOutput() LoadbalancerTargetPoolArrayOutput { + return o +} + +func (o LoadbalancerTargetPoolArrayOutput) ToLoadbalancerTargetPoolArrayOutputWithContext(ctx context.Context) LoadbalancerTargetPoolArrayOutput { + return o +} + +func (o LoadbalancerTargetPoolArrayOutput) Index(i pulumi.IntInput) LoadbalancerTargetPoolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadbalancerTargetPool { + return vs[0].([]LoadbalancerTargetPool)[vs[1].(int)] + }).(LoadbalancerTargetPoolOutput) +} + +type LoadbalancerTargetPoolActiveHealthCheck struct { + // Healthy threshold of the health checking. + HealthyThreshold *int `pulumi:"healthyThreshold"` + // Interval duration of health checking in seconds. + Interval *string `pulumi:"interval"` + // Interval duration threshold of the health checking in seconds. + IntervalJitter *string `pulumi:"intervalJitter"` + // Active health checking timeout duration in seconds. + Timeout *string `pulumi:"timeout"` + // Unhealthy threshold of the health checking. + UnhealthyThreshold *int `pulumi:"unhealthyThreshold"` +} + +// LoadbalancerTargetPoolActiveHealthCheckInput is an input type that accepts LoadbalancerTargetPoolActiveHealthCheckArgs and LoadbalancerTargetPoolActiveHealthCheckOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolActiveHealthCheckInput` via: +// +// LoadbalancerTargetPoolActiveHealthCheckArgs{...} +type LoadbalancerTargetPoolActiveHealthCheckInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolActiveHealthCheckOutput() LoadbalancerTargetPoolActiveHealthCheckOutput + ToLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(context.Context) LoadbalancerTargetPoolActiveHealthCheckOutput +} + +type LoadbalancerTargetPoolActiveHealthCheckArgs struct { + // Healthy threshold of the health checking. + HealthyThreshold pulumi.IntPtrInput `pulumi:"healthyThreshold"` + // Interval duration of health checking in seconds. + Interval pulumi.StringPtrInput `pulumi:"interval"` + // Interval duration threshold of the health checking in seconds. + IntervalJitter pulumi.StringPtrInput `pulumi:"intervalJitter"` + // Active health checking timeout duration in seconds. + Timeout pulumi.StringPtrInput `pulumi:"timeout"` + // Unhealthy threshold of the health checking. + UnhealthyThreshold pulumi.IntPtrInput `pulumi:"unhealthyThreshold"` +} + +func (LoadbalancerTargetPoolActiveHealthCheckArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolActiveHealthCheckArgs) ToLoadbalancerTargetPoolActiveHealthCheckOutput() LoadbalancerTargetPoolActiveHealthCheckOutput { + return i.ToLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolActiveHealthCheckArgs) ToLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolActiveHealthCheckOutput) +} + +func (i LoadbalancerTargetPoolActiveHealthCheckArgs) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutput() LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return i.ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolActiveHealthCheckArgs) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolActiveHealthCheckOutput).ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(ctx) +} + +// LoadbalancerTargetPoolActiveHealthCheckPtrInput is an input type that accepts LoadbalancerTargetPoolActiveHealthCheckArgs, LoadbalancerTargetPoolActiveHealthCheckPtr and LoadbalancerTargetPoolActiveHealthCheckPtrOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolActiveHealthCheckPtrInput` via: +// +// LoadbalancerTargetPoolActiveHealthCheckArgs{...} +// +// or: +// +// nil +type LoadbalancerTargetPoolActiveHealthCheckPtrInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolActiveHealthCheckPtrOutput() LoadbalancerTargetPoolActiveHealthCheckPtrOutput + ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(context.Context) LoadbalancerTargetPoolActiveHealthCheckPtrOutput +} + +type loadbalancerTargetPoolActiveHealthCheckPtrType LoadbalancerTargetPoolActiveHealthCheckArgs + +func LoadbalancerTargetPoolActiveHealthCheckPtr(v *LoadbalancerTargetPoolActiveHealthCheckArgs) LoadbalancerTargetPoolActiveHealthCheckPtrInput { + return (*loadbalancerTargetPoolActiveHealthCheckPtrType)(v) +} + +func (*loadbalancerTargetPoolActiveHealthCheckPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (i *loadbalancerTargetPoolActiveHealthCheckPtrType) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutput() LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return i.ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerTargetPoolActiveHealthCheckPtrType) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolActiveHealthCheckPtrOutput) +} + +type LoadbalancerTargetPoolActiveHealthCheckOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolActiveHealthCheckOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) ToLoadbalancerTargetPoolActiveHealthCheckOutput() LoadbalancerTargetPoolActiveHealthCheckOutput { + return o +} + +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) ToLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckOutput { + return o +} + +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutput() LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return o.ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerTargetPoolActiveHealthCheck) *LoadbalancerTargetPoolActiveHealthCheck { + return &v + }).(LoadbalancerTargetPoolActiveHealthCheckPtrOutput) +} + +// Healthy threshold of the health checking. +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) HealthyThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolActiveHealthCheck) *int { return v.HealthyThreshold }).(pulumi.IntPtrOutput) +} + +// Interval duration of health checking in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolActiveHealthCheck) *string { return v.Interval }).(pulumi.StringPtrOutput) +} + +// Interval duration threshold of the health checking in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) IntervalJitter() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolActiveHealthCheck) *string { return v.IntervalJitter }).(pulumi.StringPtrOutput) +} + +// Active health checking timeout duration in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolActiveHealthCheck) *string { return v.Timeout }).(pulumi.StringPtrOutput) +} + +// Unhealthy threshold of the health checking. +func (o LoadbalancerTargetPoolActiveHealthCheckOutput) UnhealthyThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolActiveHealthCheck) *int { return v.UnhealthyThreshold }).(pulumi.IntPtrOutput) +} + +type LoadbalancerTargetPoolActiveHealthCheckPtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolActiveHealthCheckPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutput() LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return o +} + +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) ToLoadbalancerTargetPoolActiveHealthCheckPtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolActiveHealthCheckPtrOutput { + return o +} + +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) Elem() LoadbalancerTargetPoolActiveHealthCheckOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) LoadbalancerTargetPoolActiveHealthCheck { + if v != nil { + return *v + } + var ret LoadbalancerTargetPoolActiveHealthCheck + return ret + }).(LoadbalancerTargetPoolActiveHealthCheckOutput) +} + +// Healthy threshold of the health checking. +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) HealthyThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) *int { + if v == nil { + return nil + } + return v.HealthyThreshold + }).(pulumi.IntPtrOutput) +} + +// Interval duration of health checking in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) Interval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) *string { + if v == nil { + return nil + } + return v.Interval + }).(pulumi.StringPtrOutput) +} + +// Interval duration threshold of the health checking in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) IntervalJitter() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) *string { + if v == nil { + return nil + } + return v.IntervalJitter + }).(pulumi.StringPtrOutput) +} + +// Active health checking timeout duration in seconds. +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) Timeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) *string { + if v == nil { + return nil + } + return v.Timeout + }).(pulumi.StringPtrOutput) +} + +// Unhealthy threshold of the health checking. +func (o LoadbalancerTargetPoolActiveHealthCheckPtrOutput) UnhealthyThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolActiveHealthCheck) *int { + if v == nil { + return nil + } + return v.UnhealthyThreshold + }).(pulumi.IntPtrOutput) +} + +type LoadbalancerTargetPoolSessionPersistence struct { + // If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + UseSourceIpAddress *bool `pulumi:"useSourceIpAddress"` +} + +// LoadbalancerTargetPoolSessionPersistenceInput is an input type that accepts LoadbalancerTargetPoolSessionPersistenceArgs and LoadbalancerTargetPoolSessionPersistenceOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolSessionPersistenceInput` via: +// +// LoadbalancerTargetPoolSessionPersistenceArgs{...} +type LoadbalancerTargetPoolSessionPersistenceInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolSessionPersistenceOutput() LoadbalancerTargetPoolSessionPersistenceOutput + ToLoadbalancerTargetPoolSessionPersistenceOutputWithContext(context.Context) LoadbalancerTargetPoolSessionPersistenceOutput +} + +type LoadbalancerTargetPoolSessionPersistenceArgs struct { + // If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + UseSourceIpAddress pulumi.BoolPtrInput `pulumi:"useSourceIpAddress"` +} + +func (LoadbalancerTargetPoolSessionPersistenceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolSessionPersistenceArgs) ToLoadbalancerTargetPoolSessionPersistenceOutput() LoadbalancerTargetPoolSessionPersistenceOutput { + return i.ToLoadbalancerTargetPoolSessionPersistenceOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolSessionPersistenceArgs) ToLoadbalancerTargetPoolSessionPersistenceOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistenceOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolSessionPersistenceOutput) +} + +func (i LoadbalancerTargetPoolSessionPersistenceArgs) ToLoadbalancerTargetPoolSessionPersistencePtrOutput() LoadbalancerTargetPoolSessionPersistencePtrOutput { + return i.ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolSessionPersistenceArgs) ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistencePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolSessionPersistenceOutput).ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx) +} + +// LoadbalancerTargetPoolSessionPersistencePtrInput is an input type that accepts LoadbalancerTargetPoolSessionPersistenceArgs, LoadbalancerTargetPoolSessionPersistencePtr and LoadbalancerTargetPoolSessionPersistencePtrOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolSessionPersistencePtrInput` via: +// +// LoadbalancerTargetPoolSessionPersistenceArgs{...} +// +// or: +// +// nil +type LoadbalancerTargetPoolSessionPersistencePtrInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolSessionPersistencePtrOutput() LoadbalancerTargetPoolSessionPersistencePtrOutput + ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Context) LoadbalancerTargetPoolSessionPersistencePtrOutput +} + +type loadbalancerTargetPoolSessionPersistencePtrType LoadbalancerTargetPoolSessionPersistenceArgs + +func LoadbalancerTargetPoolSessionPersistencePtr(v *LoadbalancerTargetPoolSessionPersistenceArgs) LoadbalancerTargetPoolSessionPersistencePtrInput { + return (*loadbalancerTargetPoolSessionPersistencePtrType)(v) +} + +func (*loadbalancerTargetPoolSessionPersistencePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (i *loadbalancerTargetPoolSessionPersistencePtrType) ToLoadbalancerTargetPoolSessionPersistencePtrOutput() LoadbalancerTargetPoolSessionPersistencePtrOutput { + return i.ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (i *loadbalancerTargetPoolSessionPersistencePtrType) ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistencePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +type LoadbalancerTargetPoolSessionPersistenceOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolSessionPersistenceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolSessionPersistenceOutput) ToLoadbalancerTargetPoolSessionPersistenceOutput() LoadbalancerTargetPoolSessionPersistenceOutput { + return o +} + +func (o LoadbalancerTargetPoolSessionPersistenceOutput) ToLoadbalancerTargetPoolSessionPersistenceOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistenceOutput { + return o +} + +func (o LoadbalancerTargetPoolSessionPersistenceOutput) ToLoadbalancerTargetPoolSessionPersistencePtrOutput() LoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (o LoadbalancerTargetPoolSessionPersistenceOutput) ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LoadbalancerTargetPoolSessionPersistence) *LoadbalancerTargetPoolSessionPersistence { + return &v + }).(LoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. +func (o LoadbalancerTargetPoolSessionPersistenceOutput) UseSourceIpAddress() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolSessionPersistence) *bool { return v.UseSourceIpAddress }).(pulumi.BoolPtrOutput) +} + +type LoadbalancerTargetPoolSessionPersistencePtrOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolSessionPersistencePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolSessionPersistencePtrOutput) ToLoadbalancerTargetPoolSessionPersistencePtrOutput() LoadbalancerTargetPoolSessionPersistencePtrOutput { + return o +} + +func (o LoadbalancerTargetPoolSessionPersistencePtrOutput) ToLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) LoadbalancerTargetPoolSessionPersistencePtrOutput { + return o +} + +func (o LoadbalancerTargetPoolSessionPersistencePtrOutput) Elem() LoadbalancerTargetPoolSessionPersistenceOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolSessionPersistence) LoadbalancerTargetPoolSessionPersistence { + if v != nil { + return *v + } + var ret LoadbalancerTargetPoolSessionPersistence + return ret + }).(LoadbalancerTargetPoolSessionPersistenceOutput) +} + +// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. +func (o LoadbalancerTargetPoolSessionPersistencePtrOutput) UseSourceIpAddress() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *LoadbalancerTargetPoolSessionPersistence) *bool { + if v == nil { + return nil + } + return v.UseSourceIpAddress + }).(pulumi.BoolPtrOutput) +} + +type LoadbalancerTargetPoolTarget struct { + // Target display name + DisplayName string `pulumi:"displayName"` + // Target IP + Ip string `pulumi:"ip"` +} + +// LoadbalancerTargetPoolTargetInput is an input type that accepts LoadbalancerTargetPoolTargetArgs and LoadbalancerTargetPoolTargetOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolTargetInput` via: +// +// LoadbalancerTargetPoolTargetArgs{...} +type LoadbalancerTargetPoolTargetInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolTargetOutput() LoadbalancerTargetPoolTargetOutput + ToLoadbalancerTargetPoolTargetOutputWithContext(context.Context) LoadbalancerTargetPoolTargetOutput +} + +type LoadbalancerTargetPoolTargetArgs struct { + // Target display name + DisplayName pulumi.StringInput `pulumi:"displayName"` + // Target IP + Ip pulumi.StringInput `pulumi:"ip"` +} + +func (LoadbalancerTargetPoolTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolTargetArgs) ToLoadbalancerTargetPoolTargetOutput() LoadbalancerTargetPoolTargetOutput { + return i.ToLoadbalancerTargetPoolTargetOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolTargetArgs) ToLoadbalancerTargetPoolTargetOutputWithContext(ctx context.Context) LoadbalancerTargetPoolTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolTargetOutput) +} + +// LoadbalancerTargetPoolTargetArrayInput is an input type that accepts LoadbalancerTargetPoolTargetArray and LoadbalancerTargetPoolTargetArrayOutput values. +// You can construct a concrete instance of `LoadbalancerTargetPoolTargetArrayInput` via: +// +// LoadbalancerTargetPoolTargetArray{ LoadbalancerTargetPoolTargetArgs{...} } +type LoadbalancerTargetPoolTargetArrayInput interface { + pulumi.Input + + ToLoadbalancerTargetPoolTargetArrayOutput() LoadbalancerTargetPoolTargetArrayOutput + ToLoadbalancerTargetPoolTargetArrayOutputWithContext(context.Context) LoadbalancerTargetPoolTargetArrayOutput +} + +type LoadbalancerTargetPoolTargetArray []LoadbalancerTargetPoolTargetInput + +func (LoadbalancerTargetPoolTargetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (i LoadbalancerTargetPoolTargetArray) ToLoadbalancerTargetPoolTargetArrayOutput() LoadbalancerTargetPoolTargetArrayOutput { + return i.ToLoadbalancerTargetPoolTargetArrayOutputWithContext(context.Background()) +} + +func (i LoadbalancerTargetPoolTargetArray) ToLoadbalancerTargetPoolTargetArrayOutputWithContext(ctx context.Context) LoadbalancerTargetPoolTargetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(LoadbalancerTargetPoolTargetArrayOutput) +} + +type LoadbalancerTargetPoolTargetOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolTargetOutput) ToLoadbalancerTargetPoolTargetOutput() LoadbalancerTargetPoolTargetOutput { + return o +} + +func (o LoadbalancerTargetPoolTargetOutput) ToLoadbalancerTargetPoolTargetOutputWithContext(ctx context.Context) LoadbalancerTargetPoolTargetOutput { + return o +} + +// Target display name +func (o LoadbalancerTargetPoolTargetOutput) DisplayName() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolTarget) string { return v.DisplayName }).(pulumi.StringOutput) +} + +// Target IP +func (o LoadbalancerTargetPoolTargetOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v LoadbalancerTargetPoolTarget) string { return v.Ip }).(pulumi.StringOutput) +} + +type LoadbalancerTargetPoolTargetArrayOutput struct{ *pulumi.OutputState } + +func (LoadbalancerTargetPoolTargetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]LoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (o LoadbalancerTargetPoolTargetArrayOutput) ToLoadbalancerTargetPoolTargetArrayOutput() LoadbalancerTargetPoolTargetArrayOutput { + return o +} + +func (o LoadbalancerTargetPoolTargetArrayOutput) ToLoadbalancerTargetPoolTargetArrayOutputWithContext(ctx context.Context) LoadbalancerTargetPoolTargetArrayOutput { + return o +} + +func (o LoadbalancerTargetPoolTargetArrayOutput) Index(i pulumi.IntInput) LoadbalancerTargetPoolTargetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) LoadbalancerTargetPoolTarget { + return vs[0].([]LoadbalancerTargetPoolTarget)[vs[1].(int)] + }).(LoadbalancerTargetPoolTargetOutput) +} + +type LogmeInstanceParameters struct { + // Enable monitoring. + EnableMonitoring *bool `pulumi:"enableMonitoring"` + FluentdTcp *int `pulumi:"fluentdTcp"` + FluentdTls *int `pulumi:"fluentdTls"` + FluentdTlsCiphers *string `pulumi:"fluentdTlsCiphers"` + FluentdTlsMaxVersion *string `pulumi:"fluentdTlsMaxVersion"` + FluentdTlsMinVersion *string `pulumi:"fluentdTlsMinVersion"` + FluentdTlsVersion *string `pulumi:"fluentdTlsVersion"` + FluentdUdp *int `pulumi:"fluentdUdp"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite *string `pulumi:"graphite"` + // Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + IsmDeletionAfter *string `pulumi:"ismDeletionAfter"` + IsmJitter *float64 `pulumi:"ismJitter"` + // Jitter of the execution time. + IsmJobInterval *int `pulumi:"ismJobInterval"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace *int `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace *int `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold *int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency *int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix *string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId *string `pulumi:"monitoringInstanceId"` + OpensearchTlsCiphers []string `pulumi:"opensearchTlsCiphers"` + OpensearchTlsProtocols []string `pulumi:"opensearchTlsProtocols"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl *string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` +} + +// LogmeInstanceParametersInput is an input type that accepts LogmeInstanceParametersArgs and LogmeInstanceParametersOutput values. +// You can construct a concrete instance of `LogmeInstanceParametersInput` via: +// +// LogmeInstanceParametersArgs{...} +type LogmeInstanceParametersInput interface { + pulumi.Input + + ToLogmeInstanceParametersOutput() LogmeInstanceParametersOutput + ToLogmeInstanceParametersOutputWithContext(context.Context) LogmeInstanceParametersOutput +} + +type LogmeInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolPtrInput `pulumi:"enableMonitoring"` + FluentdTcp pulumi.IntPtrInput `pulumi:"fluentdTcp"` + FluentdTls pulumi.IntPtrInput `pulumi:"fluentdTls"` + FluentdTlsCiphers pulumi.StringPtrInput `pulumi:"fluentdTlsCiphers"` + FluentdTlsMaxVersion pulumi.StringPtrInput `pulumi:"fluentdTlsMaxVersion"` + FluentdTlsMinVersion pulumi.StringPtrInput `pulumi:"fluentdTlsMinVersion"` + FluentdTlsVersion pulumi.StringPtrInput `pulumi:"fluentdTlsVersion"` + FluentdUdp pulumi.IntPtrInput `pulumi:"fluentdUdp"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite pulumi.StringPtrInput `pulumi:"graphite"` + // Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + IsmDeletionAfter pulumi.StringPtrInput `pulumi:"ismDeletionAfter"` + IsmJitter pulumi.Float64PtrInput `pulumi:"ismJitter"` + // Jitter of the execution time. + IsmJobInterval pulumi.IntPtrInput `pulumi:"ismJobInterval"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace pulumi.IntPtrInput `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace pulumi.IntPtrInput `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntPtrInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency pulumi.IntPtrInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix pulumi.StringPtrInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringPtrInput `pulumi:"monitoringInstanceId"` + OpensearchTlsCiphers pulumi.StringArrayInput `pulumi:"opensearchTlsCiphers"` + OpensearchTlsProtocols pulumi.StringArrayInput `pulumi:"opensearchTlsProtocols"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringPtrInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` +} + +func (LogmeInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LogmeInstanceParameters)(nil)).Elem() +} + +func (i LogmeInstanceParametersArgs) ToLogmeInstanceParametersOutput() LogmeInstanceParametersOutput { + return i.ToLogmeInstanceParametersOutputWithContext(context.Background()) +} + +func (i LogmeInstanceParametersArgs) ToLogmeInstanceParametersOutputWithContext(ctx context.Context) LogmeInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceParametersOutput) +} + +func (i LogmeInstanceParametersArgs) ToLogmeInstanceParametersPtrOutput() LogmeInstanceParametersPtrOutput { + return i.ToLogmeInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i LogmeInstanceParametersArgs) ToLogmeInstanceParametersPtrOutputWithContext(ctx context.Context) LogmeInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceParametersOutput).ToLogmeInstanceParametersPtrOutputWithContext(ctx) +} + +// LogmeInstanceParametersPtrInput is an input type that accepts LogmeInstanceParametersArgs, LogmeInstanceParametersPtr and LogmeInstanceParametersPtrOutput values. +// You can construct a concrete instance of `LogmeInstanceParametersPtrInput` via: +// +// LogmeInstanceParametersArgs{...} +// +// or: +// +// nil +type LogmeInstanceParametersPtrInput interface { + pulumi.Input + + ToLogmeInstanceParametersPtrOutput() LogmeInstanceParametersPtrOutput + ToLogmeInstanceParametersPtrOutputWithContext(context.Context) LogmeInstanceParametersPtrOutput +} + +type logmeInstanceParametersPtrType LogmeInstanceParametersArgs + +func LogmeInstanceParametersPtr(v *LogmeInstanceParametersArgs) LogmeInstanceParametersPtrInput { + return (*logmeInstanceParametersPtrType)(v) +} + +func (*logmeInstanceParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeInstanceParameters)(nil)).Elem() +} + +func (i *logmeInstanceParametersPtrType) ToLogmeInstanceParametersPtrOutput() LogmeInstanceParametersPtrOutput { + return i.ToLogmeInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i *logmeInstanceParametersPtrType) ToLogmeInstanceParametersPtrOutputWithContext(ctx context.Context) LogmeInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(LogmeInstanceParametersPtrOutput) +} + +type LogmeInstanceParametersOutput struct{ *pulumi.OutputState } + +func (LogmeInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LogmeInstanceParameters)(nil)).Elem() +} + +func (o LogmeInstanceParametersOutput) ToLogmeInstanceParametersOutput() LogmeInstanceParametersOutput { + return o +} + +func (o LogmeInstanceParametersOutput) ToLogmeInstanceParametersOutputWithContext(ctx context.Context) LogmeInstanceParametersOutput { + return o +} + +func (o LogmeInstanceParametersOutput) ToLogmeInstanceParametersPtrOutput() LogmeInstanceParametersPtrOutput { + return o.ToLogmeInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (o LogmeInstanceParametersOutput) ToLogmeInstanceParametersPtrOutputWithContext(ctx context.Context) LogmeInstanceParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v LogmeInstanceParameters) *LogmeInstanceParameters { + return &v + }).(LogmeInstanceParametersPtrOutput) +} + +// Enable monitoring. +func (o LogmeInstanceParametersOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *bool { return v.EnableMonitoring }).(pulumi.BoolPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTcp() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.FluentdTcp }).(pulumi.IntPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTls() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.FluentdTls }).(pulumi.IntPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTlsCiphers() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.FluentdTlsCiphers }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTlsMaxVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.FluentdTlsMaxVersion }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTlsMinVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.FluentdTlsMinVersion }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdTlsVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.FluentdTlsVersion }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) FluentdUdp() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.FluentdUdp }).(pulumi.IntPtrOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o LogmeInstanceParametersOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.Graphite }).(pulumi.StringPtrOutput) +} + +// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. +func (o LogmeInstanceParametersOutput) IsmDeletionAfter() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.IsmDeletionAfter }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) IsmJitter() pulumi.Float64PtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *float64 { return v.IsmJitter }).(pulumi.Float64PtrOutput) +} + +// Jitter of the execution time. +func (o LogmeInstanceParametersOutput) IsmJobInterval() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.IsmJobInterval }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o LogmeInstanceParametersOutput) JavaHeapspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.JavaHeapspace }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o LogmeInstanceParametersOutput) JavaMaxmetaspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.JavaMaxmetaspace }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o LogmeInstanceParametersOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.MaxDiskThreshold }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o LogmeInstanceParametersOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *int { return v.MetricsFrequency }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o LogmeInstanceParametersOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.MetricsPrefix }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o LogmeInstanceParametersOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.MonitoringInstanceId }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersOutput) OpensearchTlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v LogmeInstanceParameters) []string { return v.OpensearchTlsCiphers }).(pulumi.StringArrayOutput) +} + +func (o LogmeInstanceParametersOutput) OpensearchTlsProtocols() pulumi.StringArrayOutput { + return o.ApplyT(func(v LogmeInstanceParameters) []string { return v.OpensearchTlsProtocols }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o LogmeInstanceParametersOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v LogmeInstanceParameters) *string { return v.SgwAcl }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o LogmeInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v LogmeInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +type LogmeInstanceParametersPtrOutput struct{ *pulumi.OutputState } + +func (LogmeInstanceParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**LogmeInstanceParameters)(nil)).Elem() +} + +func (o LogmeInstanceParametersPtrOutput) ToLogmeInstanceParametersPtrOutput() LogmeInstanceParametersPtrOutput { + return o +} + +func (o LogmeInstanceParametersPtrOutput) ToLogmeInstanceParametersPtrOutputWithContext(ctx context.Context) LogmeInstanceParametersPtrOutput { + return o +} + +func (o LogmeInstanceParametersPtrOutput) Elem() LogmeInstanceParametersOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) LogmeInstanceParameters { + if v != nil { + return *v + } + var ret LogmeInstanceParameters + return ret + }).(LogmeInstanceParametersOutput) +} + +// Enable monitoring. +func (o LogmeInstanceParametersPtrOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *bool { + if v == nil { + return nil + } + return v.EnableMonitoring + }).(pulumi.BoolPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTcp() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.FluentdTcp + }).(pulumi.IntPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTls() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.FluentdTls + }).(pulumi.IntPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTlsCiphers() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.FluentdTlsCiphers + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTlsMaxVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.FluentdTlsMaxVersion + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTlsMinVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.FluentdTlsMinVersion + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdTlsVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.FluentdTlsVersion + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) FluentdUdp() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.FluentdUdp + }).(pulumi.IntPtrOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o LogmeInstanceParametersPtrOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.Graphite + }).(pulumi.StringPtrOutput) +} + +// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. +func (o LogmeInstanceParametersPtrOutput) IsmDeletionAfter() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.IsmDeletionAfter + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) IsmJitter() pulumi.Float64PtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *float64 { + if v == nil { + return nil + } + return v.IsmJitter + }).(pulumi.Float64PtrOutput) +} + +// Jitter of the execution time. +func (o LogmeInstanceParametersPtrOutput) IsmJobInterval() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.IsmJobInterval + }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o LogmeInstanceParametersPtrOutput) JavaHeapspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.JavaHeapspace + }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o LogmeInstanceParametersPtrOutput) JavaMaxmetaspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.JavaMaxmetaspace + }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o LogmeInstanceParametersPtrOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxDiskThreshold + }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o LogmeInstanceParametersPtrOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *int { + if v == nil { + return nil + } + return v.MetricsFrequency + }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o LogmeInstanceParametersPtrOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.MetricsPrefix + }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o LogmeInstanceParametersPtrOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.MonitoringInstanceId + }).(pulumi.StringPtrOutput) +} + +func (o LogmeInstanceParametersPtrOutput) OpensearchTlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) []string { + if v == nil { + return nil + } + return v.OpensearchTlsCiphers + }).(pulumi.StringArrayOutput) +} + +func (o LogmeInstanceParametersPtrOutput) OpensearchTlsProtocols() pulumi.StringArrayOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) []string { + if v == nil { + return nil + } + return v.OpensearchTlsProtocols + }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o LogmeInstanceParametersPtrOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) *string { + if v == nil { + return nil + } + return v.SgwAcl + }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o LogmeInstanceParametersPtrOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *LogmeInstanceParameters) []string { + if v == nil { + return nil + } + return v.Syslogs + }).(pulumi.StringArrayOutput) +} + +type MariadbInstanceParameters struct { + // Enable monitoring. + EnableMonitoring *bool `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite *string `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold *int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency *int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix *string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + MonitoringInstanceId *string `pulumi:"monitoringInstanceId"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl *string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` +} + +// MariadbInstanceParametersInput is an input type that accepts MariadbInstanceParametersArgs and MariadbInstanceParametersOutput values. +// You can construct a concrete instance of `MariadbInstanceParametersInput` via: +// +// MariadbInstanceParametersArgs{...} +type MariadbInstanceParametersInput interface { + pulumi.Input + + ToMariadbInstanceParametersOutput() MariadbInstanceParametersOutput + ToMariadbInstanceParametersOutputWithContext(context.Context) MariadbInstanceParametersOutput +} + +type MariadbInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolPtrInput `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite pulumi.StringPtrInput `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntPtrInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntPtrInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringPtrInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + MonitoringInstanceId pulumi.StringPtrInput `pulumi:"monitoringInstanceId"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringPtrInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` +} + +func (MariadbInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*MariadbInstanceParameters)(nil)).Elem() +} + +func (i MariadbInstanceParametersArgs) ToMariadbInstanceParametersOutput() MariadbInstanceParametersOutput { + return i.ToMariadbInstanceParametersOutputWithContext(context.Background()) +} + +func (i MariadbInstanceParametersArgs) ToMariadbInstanceParametersOutputWithContext(ctx context.Context) MariadbInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceParametersOutput) +} + +func (i MariadbInstanceParametersArgs) ToMariadbInstanceParametersPtrOutput() MariadbInstanceParametersPtrOutput { + return i.ToMariadbInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i MariadbInstanceParametersArgs) ToMariadbInstanceParametersPtrOutputWithContext(ctx context.Context) MariadbInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceParametersOutput).ToMariadbInstanceParametersPtrOutputWithContext(ctx) +} + +// MariadbInstanceParametersPtrInput is an input type that accepts MariadbInstanceParametersArgs, MariadbInstanceParametersPtr and MariadbInstanceParametersPtrOutput values. +// You can construct a concrete instance of `MariadbInstanceParametersPtrInput` via: +// +// MariadbInstanceParametersArgs{...} +// +// or: +// +// nil +type MariadbInstanceParametersPtrInput interface { + pulumi.Input + + ToMariadbInstanceParametersPtrOutput() MariadbInstanceParametersPtrOutput + ToMariadbInstanceParametersPtrOutputWithContext(context.Context) MariadbInstanceParametersPtrOutput +} + +type mariadbInstanceParametersPtrType MariadbInstanceParametersArgs + +func MariadbInstanceParametersPtr(v *MariadbInstanceParametersArgs) MariadbInstanceParametersPtrInput { + return (*mariadbInstanceParametersPtrType)(v) +} + +func (*mariadbInstanceParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbInstanceParameters)(nil)).Elem() +} + +func (i *mariadbInstanceParametersPtrType) ToMariadbInstanceParametersPtrOutput() MariadbInstanceParametersPtrOutput { + return i.ToMariadbInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i *mariadbInstanceParametersPtrType) ToMariadbInstanceParametersPtrOutputWithContext(ctx context.Context) MariadbInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MariadbInstanceParametersPtrOutput) +} + +type MariadbInstanceParametersOutput struct{ *pulumi.OutputState } + +func (MariadbInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*MariadbInstanceParameters)(nil)).Elem() +} + +func (o MariadbInstanceParametersOutput) ToMariadbInstanceParametersOutput() MariadbInstanceParametersOutput { + return o +} + +func (o MariadbInstanceParametersOutput) ToMariadbInstanceParametersOutputWithContext(ctx context.Context) MariadbInstanceParametersOutput { + return o +} + +func (o MariadbInstanceParametersOutput) ToMariadbInstanceParametersPtrOutput() MariadbInstanceParametersPtrOutput { + return o.ToMariadbInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (o MariadbInstanceParametersOutput) ToMariadbInstanceParametersPtrOutputWithContext(ctx context.Context) MariadbInstanceParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v MariadbInstanceParameters) *MariadbInstanceParameters { + return &v + }).(MariadbInstanceParametersPtrOutput) +} + +// Enable monitoring. +func (o MariadbInstanceParametersOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *bool { return v.EnableMonitoring }).(pulumi.BoolPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o MariadbInstanceParametersOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *string { return v.Graphite }).(pulumi.StringPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o MariadbInstanceParametersOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *int { return v.MaxDiskThreshold }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o MariadbInstanceParametersOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *int { return v.MetricsFrequency }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o MariadbInstanceParametersOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *string { return v.MetricsPrefix }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. +func (o MariadbInstanceParametersOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *string { return v.MonitoringInstanceId }).(pulumi.StringPtrOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o MariadbInstanceParametersOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v MariadbInstanceParameters) *string { return v.SgwAcl }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o MariadbInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v MariadbInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +type MariadbInstanceParametersPtrOutput struct{ *pulumi.OutputState } + +func (MariadbInstanceParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MariadbInstanceParameters)(nil)).Elem() +} + +func (o MariadbInstanceParametersPtrOutput) ToMariadbInstanceParametersPtrOutput() MariadbInstanceParametersPtrOutput { + return o +} + +func (o MariadbInstanceParametersPtrOutput) ToMariadbInstanceParametersPtrOutputWithContext(ctx context.Context) MariadbInstanceParametersPtrOutput { + return o +} + +func (o MariadbInstanceParametersPtrOutput) Elem() MariadbInstanceParametersOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) MariadbInstanceParameters { + if v != nil { + return *v + } + var ret MariadbInstanceParameters + return ret + }).(MariadbInstanceParametersOutput) +} + +// Enable monitoring. +func (o MariadbInstanceParametersPtrOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *bool { + if v == nil { + return nil + } + return v.EnableMonitoring + }).(pulumi.BoolPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o MariadbInstanceParametersPtrOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *string { + if v == nil { + return nil + } + return v.Graphite + }).(pulumi.StringPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o MariadbInstanceParametersPtrOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxDiskThreshold + }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o MariadbInstanceParametersPtrOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *int { + if v == nil { + return nil + } + return v.MetricsFrequency + }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o MariadbInstanceParametersPtrOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *string { + if v == nil { + return nil + } + return v.MetricsPrefix + }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. +func (o MariadbInstanceParametersPtrOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *string { + if v == nil { + return nil + } + return v.MonitoringInstanceId + }).(pulumi.StringPtrOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o MariadbInstanceParametersPtrOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) *string { + if v == nil { + return nil + } + return v.SgwAcl + }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o MariadbInstanceParametersPtrOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *MariadbInstanceParameters) []string { + if v == nil { + return nil + } + return v.Syslogs + }).(pulumi.StringArrayOutput) +} + +type MongodbflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description *string `pulumi:"description"` + Id *string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// MongodbflexInstanceFlavorInput is an input type that accepts MongodbflexInstanceFlavorArgs and MongodbflexInstanceFlavorOutput values. +// You can construct a concrete instance of `MongodbflexInstanceFlavorInput` via: +// +// MongodbflexInstanceFlavorArgs{...} +type MongodbflexInstanceFlavorInput interface { + pulumi.Input + + ToMongodbflexInstanceFlavorOutput() MongodbflexInstanceFlavorOutput + ToMongodbflexInstanceFlavorOutputWithContext(context.Context) MongodbflexInstanceFlavorOutput +} + +type MongodbflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringPtrInput `pulumi:"description"` + Id pulumi.StringPtrInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (MongodbflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceFlavor)(nil)).Elem() +} + +func (i MongodbflexInstanceFlavorArgs) ToMongodbflexInstanceFlavorOutput() MongodbflexInstanceFlavorOutput { + return i.ToMongodbflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceFlavorArgs) ToMongodbflexInstanceFlavorOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceFlavorOutput) +} + +func (i MongodbflexInstanceFlavorArgs) ToMongodbflexInstanceFlavorPtrOutput() MongodbflexInstanceFlavorPtrOutput { + return i.ToMongodbflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceFlavorArgs) ToMongodbflexInstanceFlavorPtrOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceFlavorOutput).ToMongodbflexInstanceFlavorPtrOutputWithContext(ctx) +} + +// MongodbflexInstanceFlavorPtrInput is an input type that accepts MongodbflexInstanceFlavorArgs, MongodbflexInstanceFlavorPtr and MongodbflexInstanceFlavorPtrOutput values. +// You can construct a concrete instance of `MongodbflexInstanceFlavorPtrInput` via: +// +// MongodbflexInstanceFlavorArgs{...} +// +// or: +// +// nil +type MongodbflexInstanceFlavorPtrInput interface { + pulumi.Input + + ToMongodbflexInstanceFlavorPtrOutput() MongodbflexInstanceFlavorPtrOutput + ToMongodbflexInstanceFlavorPtrOutputWithContext(context.Context) MongodbflexInstanceFlavorPtrOutput +} + +type mongodbflexInstanceFlavorPtrType MongodbflexInstanceFlavorArgs + +func MongodbflexInstanceFlavorPtr(v *MongodbflexInstanceFlavorArgs) MongodbflexInstanceFlavorPtrInput { + return (*mongodbflexInstanceFlavorPtrType)(v) +} + +func (*mongodbflexInstanceFlavorPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceFlavor)(nil)).Elem() +} + +func (i *mongodbflexInstanceFlavorPtrType) ToMongodbflexInstanceFlavorPtrOutput() MongodbflexInstanceFlavorPtrOutput { + return i.ToMongodbflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i *mongodbflexInstanceFlavorPtrType) ToMongodbflexInstanceFlavorPtrOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceFlavorPtrOutput) +} + +type MongodbflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceFlavor)(nil)).Elem() +} + +func (o MongodbflexInstanceFlavorOutput) ToMongodbflexInstanceFlavorOutput() MongodbflexInstanceFlavorOutput { + return o +} + +func (o MongodbflexInstanceFlavorOutput) ToMongodbflexInstanceFlavorOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorOutput { + return o +} + +func (o MongodbflexInstanceFlavorOutput) ToMongodbflexInstanceFlavorPtrOutput() MongodbflexInstanceFlavorPtrOutput { + return o.ToMongodbflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (o MongodbflexInstanceFlavorOutput) ToMongodbflexInstanceFlavorPtrOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v MongodbflexInstanceFlavor) *MongodbflexInstanceFlavor { + return &v + }).(MongodbflexInstanceFlavorPtrOutput) +} + +func (o MongodbflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v MongodbflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o MongodbflexInstanceFlavorOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceFlavor) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o MongodbflexInstanceFlavorOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceFlavor) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +func (o MongodbflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v MongodbflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type MongodbflexInstanceFlavorPtrOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceFlavorPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceFlavor)(nil)).Elem() +} + +func (o MongodbflexInstanceFlavorPtrOutput) ToMongodbflexInstanceFlavorPtrOutput() MongodbflexInstanceFlavorPtrOutput { + return o +} + +func (o MongodbflexInstanceFlavorPtrOutput) ToMongodbflexInstanceFlavorPtrOutputWithContext(ctx context.Context) MongodbflexInstanceFlavorPtrOutput { + return o +} + +func (o MongodbflexInstanceFlavorPtrOutput) Elem() MongodbflexInstanceFlavorOutput { + return o.ApplyT(func(v *MongodbflexInstanceFlavor) MongodbflexInstanceFlavor { + if v != nil { + return *v + } + var ret MongodbflexInstanceFlavor + return ret + }).(MongodbflexInstanceFlavorOutput) +} + +func (o MongodbflexInstanceFlavorPtrOutput) Cpu() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Cpu + }).(pulumi.IntPtrOutput) +} + +func (o MongodbflexInstanceFlavorPtrOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Description + }).(pulumi.StringPtrOutput) +} + +func (o MongodbflexInstanceFlavorPtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Id + }).(pulumi.StringPtrOutput) +} + +func (o MongodbflexInstanceFlavorPtrOutput) Ram() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Ram + }).(pulumi.IntPtrOutput) +} + +type MongodbflexInstanceOptions struct { + // The number of days that daily backups will be retained. + DailySnapshotRetentionDays *int `pulumi:"dailySnapshotRetentionDays"` + // The number of months that monthly backups will be retained. + MonthlySnapshotRetentionMonths *int `pulumi:"monthlySnapshotRetentionMonths"` + // The number of hours back in time the point-in-time recovery feature will be able to recover. + PointInTimeWindowHours int `pulumi:"pointInTimeWindowHours"` + // The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + SnapshotRetentionDays *int `pulumi:"snapshotRetentionDays"` + // Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + Type string `pulumi:"type"` + // The number of weeks that weekly backups will be retained. + WeeklySnapshotRetentionWeeks *int `pulumi:"weeklySnapshotRetentionWeeks"` +} + +// MongodbflexInstanceOptionsInput is an input type that accepts MongodbflexInstanceOptionsArgs and MongodbflexInstanceOptionsOutput values. +// You can construct a concrete instance of `MongodbflexInstanceOptionsInput` via: +// +// MongodbflexInstanceOptionsArgs{...} +type MongodbflexInstanceOptionsInput interface { + pulumi.Input + + ToMongodbflexInstanceOptionsOutput() MongodbflexInstanceOptionsOutput + ToMongodbflexInstanceOptionsOutputWithContext(context.Context) MongodbflexInstanceOptionsOutput +} + +type MongodbflexInstanceOptionsArgs struct { + // The number of days that daily backups will be retained. + DailySnapshotRetentionDays pulumi.IntPtrInput `pulumi:"dailySnapshotRetentionDays"` + // The number of months that monthly backups will be retained. + MonthlySnapshotRetentionMonths pulumi.IntPtrInput `pulumi:"monthlySnapshotRetentionMonths"` + // The number of hours back in time the point-in-time recovery feature will be able to recover. + PointInTimeWindowHours pulumi.IntInput `pulumi:"pointInTimeWindowHours"` + // The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + SnapshotRetentionDays pulumi.IntPtrInput `pulumi:"snapshotRetentionDays"` + // Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + Type pulumi.StringInput `pulumi:"type"` + // The number of weeks that weekly backups will be retained. + WeeklySnapshotRetentionWeeks pulumi.IntPtrInput `pulumi:"weeklySnapshotRetentionWeeks"` +} + +func (MongodbflexInstanceOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceOptions)(nil)).Elem() +} + +func (i MongodbflexInstanceOptionsArgs) ToMongodbflexInstanceOptionsOutput() MongodbflexInstanceOptionsOutput { + return i.ToMongodbflexInstanceOptionsOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceOptionsArgs) ToMongodbflexInstanceOptionsOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceOptionsOutput) +} + +func (i MongodbflexInstanceOptionsArgs) ToMongodbflexInstanceOptionsPtrOutput() MongodbflexInstanceOptionsPtrOutput { + return i.ToMongodbflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceOptionsArgs) ToMongodbflexInstanceOptionsPtrOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceOptionsOutput).ToMongodbflexInstanceOptionsPtrOutputWithContext(ctx) +} + +// MongodbflexInstanceOptionsPtrInput is an input type that accepts MongodbflexInstanceOptionsArgs, MongodbflexInstanceOptionsPtr and MongodbflexInstanceOptionsPtrOutput values. +// You can construct a concrete instance of `MongodbflexInstanceOptionsPtrInput` via: +// +// MongodbflexInstanceOptionsArgs{...} +// +// or: +// +// nil +type MongodbflexInstanceOptionsPtrInput interface { + pulumi.Input + + ToMongodbflexInstanceOptionsPtrOutput() MongodbflexInstanceOptionsPtrOutput + ToMongodbflexInstanceOptionsPtrOutputWithContext(context.Context) MongodbflexInstanceOptionsPtrOutput +} + +type mongodbflexInstanceOptionsPtrType MongodbflexInstanceOptionsArgs + +func MongodbflexInstanceOptionsPtr(v *MongodbflexInstanceOptionsArgs) MongodbflexInstanceOptionsPtrInput { + return (*mongodbflexInstanceOptionsPtrType)(v) +} + +func (*mongodbflexInstanceOptionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceOptions)(nil)).Elem() +} + +func (i *mongodbflexInstanceOptionsPtrType) ToMongodbflexInstanceOptionsPtrOutput() MongodbflexInstanceOptionsPtrOutput { + return i.ToMongodbflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (i *mongodbflexInstanceOptionsPtrType) ToMongodbflexInstanceOptionsPtrOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceOptionsPtrOutput) +} + +type MongodbflexInstanceOptionsOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceOptions)(nil)).Elem() +} + +func (o MongodbflexInstanceOptionsOutput) ToMongodbflexInstanceOptionsOutput() MongodbflexInstanceOptionsOutput { + return o +} + +func (o MongodbflexInstanceOptionsOutput) ToMongodbflexInstanceOptionsOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsOutput { + return o +} + +func (o MongodbflexInstanceOptionsOutput) ToMongodbflexInstanceOptionsPtrOutput() MongodbflexInstanceOptionsPtrOutput { + return o.ToMongodbflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (o MongodbflexInstanceOptionsOutput) ToMongodbflexInstanceOptionsPtrOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v MongodbflexInstanceOptions) *MongodbflexInstanceOptions { + return &v + }).(MongodbflexInstanceOptionsPtrOutput) +} + +// The number of days that daily backups will be retained. +func (o MongodbflexInstanceOptionsOutput) DailySnapshotRetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) *int { return v.DailySnapshotRetentionDays }).(pulumi.IntPtrOutput) +} + +// The number of months that monthly backups will be retained. +func (o MongodbflexInstanceOptionsOutput) MonthlySnapshotRetentionMonths() pulumi.IntPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) *int { return v.MonthlySnapshotRetentionMonths }).(pulumi.IntPtrOutput) +} + +// The number of hours back in time the point-in-time recovery feature will be able to recover. +func (o MongodbflexInstanceOptionsOutput) PointInTimeWindowHours() pulumi.IntOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) int { return v.PointInTimeWindowHours }).(pulumi.IntOutput) +} + +// The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. +func (o MongodbflexInstanceOptionsOutput) SnapshotRetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) *int { return v.SnapshotRetentionDays }).(pulumi.IntPtrOutput) +} + +// Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. +func (o MongodbflexInstanceOptionsOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) string { return v.Type }).(pulumi.StringOutput) +} + +// The number of weeks that weekly backups will be retained. +func (o MongodbflexInstanceOptionsOutput) WeeklySnapshotRetentionWeeks() pulumi.IntPtrOutput { + return o.ApplyT(func(v MongodbflexInstanceOptions) *int { return v.WeeklySnapshotRetentionWeeks }).(pulumi.IntPtrOutput) +} + +type MongodbflexInstanceOptionsPtrOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceOptionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceOptions)(nil)).Elem() +} + +func (o MongodbflexInstanceOptionsPtrOutput) ToMongodbflexInstanceOptionsPtrOutput() MongodbflexInstanceOptionsPtrOutput { + return o +} + +func (o MongodbflexInstanceOptionsPtrOutput) ToMongodbflexInstanceOptionsPtrOutputWithContext(ctx context.Context) MongodbflexInstanceOptionsPtrOutput { + return o +} + +func (o MongodbflexInstanceOptionsPtrOutput) Elem() MongodbflexInstanceOptionsOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) MongodbflexInstanceOptions { + if v != nil { + return *v + } + var ret MongodbflexInstanceOptions + return ret + }).(MongodbflexInstanceOptionsOutput) +} + +// The number of days that daily backups will be retained. +func (o MongodbflexInstanceOptionsPtrOutput) DailySnapshotRetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *int { + if v == nil { + return nil + } + return v.DailySnapshotRetentionDays + }).(pulumi.IntPtrOutput) +} + +// The number of months that monthly backups will be retained. +func (o MongodbflexInstanceOptionsPtrOutput) MonthlySnapshotRetentionMonths() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *int { + if v == nil { + return nil + } + return v.MonthlySnapshotRetentionMonths + }).(pulumi.IntPtrOutput) +} + +// The number of hours back in time the point-in-time recovery feature will be able to recover. +func (o MongodbflexInstanceOptionsPtrOutput) PointInTimeWindowHours() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *int { + if v == nil { + return nil + } + return &v.PointInTimeWindowHours + }).(pulumi.IntPtrOutput) +} + +// The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. +func (o MongodbflexInstanceOptionsPtrOutput) SnapshotRetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *int { + if v == nil { + return nil + } + return v.SnapshotRetentionDays + }).(pulumi.IntPtrOutput) +} + +// Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. +func (o MongodbflexInstanceOptionsPtrOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *string { + if v == nil { + return nil + } + return &v.Type + }).(pulumi.StringPtrOutput) +} + +// The number of weeks that weekly backups will be retained. +func (o MongodbflexInstanceOptionsPtrOutput) WeeklySnapshotRetentionWeeks() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceOptions) *int { + if v == nil { + return nil + } + return v.WeeklySnapshotRetentionWeeks + }).(pulumi.IntPtrOutput) +} + +type MongodbflexInstanceStorage struct { + Class string `pulumi:"class"` + Size int `pulumi:"size"` +} + +// MongodbflexInstanceStorageInput is an input type that accepts MongodbflexInstanceStorageArgs and MongodbflexInstanceStorageOutput values. +// You can construct a concrete instance of `MongodbflexInstanceStorageInput` via: +// +// MongodbflexInstanceStorageArgs{...} +type MongodbflexInstanceStorageInput interface { + pulumi.Input + + ToMongodbflexInstanceStorageOutput() MongodbflexInstanceStorageOutput + ToMongodbflexInstanceStorageOutputWithContext(context.Context) MongodbflexInstanceStorageOutput +} + +type MongodbflexInstanceStorageArgs struct { + Class pulumi.StringInput `pulumi:"class"` + Size pulumi.IntInput `pulumi:"size"` +} + +func (MongodbflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceStorage)(nil)).Elem() +} + +func (i MongodbflexInstanceStorageArgs) ToMongodbflexInstanceStorageOutput() MongodbflexInstanceStorageOutput { + return i.ToMongodbflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceStorageArgs) ToMongodbflexInstanceStorageOutputWithContext(ctx context.Context) MongodbflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceStorageOutput) +} + +func (i MongodbflexInstanceStorageArgs) ToMongodbflexInstanceStoragePtrOutput() MongodbflexInstanceStoragePtrOutput { + return i.ToMongodbflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i MongodbflexInstanceStorageArgs) ToMongodbflexInstanceStoragePtrOutputWithContext(ctx context.Context) MongodbflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceStorageOutput).ToMongodbflexInstanceStoragePtrOutputWithContext(ctx) +} + +// MongodbflexInstanceStoragePtrInput is an input type that accepts MongodbflexInstanceStorageArgs, MongodbflexInstanceStoragePtr and MongodbflexInstanceStoragePtrOutput values. +// You can construct a concrete instance of `MongodbflexInstanceStoragePtrInput` via: +// +// MongodbflexInstanceStorageArgs{...} +// +// or: +// +// nil +type MongodbflexInstanceStoragePtrInput interface { + pulumi.Input + + ToMongodbflexInstanceStoragePtrOutput() MongodbflexInstanceStoragePtrOutput + ToMongodbflexInstanceStoragePtrOutputWithContext(context.Context) MongodbflexInstanceStoragePtrOutput +} + +type mongodbflexInstanceStoragePtrType MongodbflexInstanceStorageArgs + +func MongodbflexInstanceStoragePtr(v *MongodbflexInstanceStorageArgs) MongodbflexInstanceStoragePtrInput { + return (*mongodbflexInstanceStoragePtrType)(v) +} + +func (*mongodbflexInstanceStoragePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceStorage)(nil)).Elem() +} + +func (i *mongodbflexInstanceStoragePtrType) ToMongodbflexInstanceStoragePtrOutput() MongodbflexInstanceStoragePtrOutput { + return i.ToMongodbflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i *mongodbflexInstanceStoragePtrType) ToMongodbflexInstanceStoragePtrOutputWithContext(ctx context.Context) MongodbflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(MongodbflexInstanceStoragePtrOutput) +} + +type MongodbflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*MongodbflexInstanceStorage)(nil)).Elem() +} + +func (o MongodbflexInstanceStorageOutput) ToMongodbflexInstanceStorageOutput() MongodbflexInstanceStorageOutput { + return o +} + +func (o MongodbflexInstanceStorageOutput) ToMongodbflexInstanceStorageOutputWithContext(ctx context.Context) MongodbflexInstanceStorageOutput { + return o +} + +func (o MongodbflexInstanceStorageOutput) ToMongodbflexInstanceStoragePtrOutput() MongodbflexInstanceStoragePtrOutput { + return o.ToMongodbflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (o MongodbflexInstanceStorageOutput) ToMongodbflexInstanceStoragePtrOutputWithContext(ctx context.Context) MongodbflexInstanceStoragePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v MongodbflexInstanceStorage) *MongodbflexInstanceStorage { + return &v + }).(MongodbflexInstanceStoragePtrOutput) +} + +func (o MongodbflexInstanceStorageOutput) Class() pulumi.StringOutput { + return o.ApplyT(func(v MongodbflexInstanceStorage) string { return v.Class }).(pulumi.StringOutput) +} + +func (o MongodbflexInstanceStorageOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v MongodbflexInstanceStorage) int { return v.Size }).(pulumi.IntOutput) +} + +type MongodbflexInstanceStoragePtrOutput struct{ *pulumi.OutputState } + +func (MongodbflexInstanceStoragePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**MongodbflexInstanceStorage)(nil)).Elem() +} + +func (o MongodbflexInstanceStoragePtrOutput) ToMongodbflexInstanceStoragePtrOutput() MongodbflexInstanceStoragePtrOutput { + return o +} + +func (o MongodbflexInstanceStoragePtrOutput) ToMongodbflexInstanceStoragePtrOutputWithContext(ctx context.Context) MongodbflexInstanceStoragePtrOutput { + return o +} + +func (o MongodbflexInstanceStoragePtrOutput) Elem() MongodbflexInstanceStorageOutput { + return o.ApplyT(func(v *MongodbflexInstanceStorage) MongodbflexInstanceStorage { + if v != nil { + return *v + } + var ret MongodbflexInstanceStorage + return ret + }).(MongodbflexInstanceStorageOutput) +} + +func (o MongodbflexInstanceStoragePtrOutput) Class() pulumi.StringPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceStorage) *string { + if v == nil { + return nil + } + return &v.Class + }).(pulumi.StringPtrOutput) +} + +func (o MongodbflexInstanceStoragePtrOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v *MongodbflexInstanceStorage) *int { + if v == nil { + return nil + } + return &v.Size + }).(pulumi.IntPtrOutput) +} + +type NetworkAreaNetworkRange struct { + NetworkRangeId *string `pulumi:"networkRangeId"` + // Classless Inter-Domain Routing (CIDR). + Prefix string `pulumi:"prefix"` +} + +// NetworkAreaNetworkRangeInput is an input type that accepts NetworkAreaNetworkRangeArgs and NetworkAreaNetworkRangeOutput values. +// You can construct a concrete instance of `NetworkAreaNetworkRangeInput` via: +// +// NetworkAreaNetworkRangeArgs{...} +type NetworkAreaNetworkRangeInput interface { + pulumi.Input + + ToNetworkAreaNetworkRangeOutput() NetworkAreaNetworkRangeOutput + ToNetworkAreaNetworkRangeOutputWithContext(context.Context) NetworkAreaNetworkRangeOutput +} + +type NetworkAreaNetworkRangeArgs struct { + NetworkRangeId pulumi.StringPtrInput `pulumi:"networkRangeId"` + // Classless Inter-Domain Routing (CIDR). + Prefix pulumi.StringInput `pulumi:"prefix"` +} + +func (NetworkAreaNetworkRangeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*NetworkAreaNetworkRange)(nil)).Elem() +} + +func (i NetworkAreaNetworkRangeArgs) ToNetworkAreaNetworkRangeOutput() NetworkAreaNetworkRangeOutput { + return i.ToNetworkAreaNetworkRangeOutputWithContext(context.Background()) +} + +func (i NetworkAreaNetworkRangeArgs) ToNetworkAreaNetworkRangeOutputWithContext(ctx context.Context) NetworkAreaNetworkRangeOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaNetworkRangeOutput) +} + +// NetworkAreaNetworkRangeArrayInput is an input type that accepts NetworkAreaNetworkRangeArray and NetworkAreaNetworkRangeArrayOutput values. +// You can construct a concrete instance of `NetworkAreaNetworkRangeArrayInput` via: +// +// NetworkAreaNetworkRangeArray{ NetworkAreaNetworkRangeArgs{...} } +type NetworkAreaNetworkRangeArrayInput interface { + pulumi.Input + + ToNetworkAreaNetworkRangeArrayOutput() NetworkAreaNetworkRangeArrayOutput + ToNetworkAreaNetworkRangeArrayOutputWithContext(context.Context) NetworkAreaNetworkRangeArrayOutput +} + +type NetworkAreaNetworkRangeArray []NetworkAreaNetworkRangeInput + +func (NetworkAreaNetworkRangeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]NetworkAreaNetworkRange)(nil)).Elem() +} + +func (i NetworkAreaNetworkRangeArray) ToNetworkAreaNetworkRangeArrayOutput() NetworkAreaNetworkRangeArrayOutput { + return i.ToNetworkAreaNetworkRangeArrayOutputWithContext(context.Background()) +} + +func (i NetworkAreaNetworkRangeArray) ToNetworkAreaNetworkRangeArrayOutputWithContext(ctx context.Context) NetworkAreaNetworkRangeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(NetworkAreaNetworkRangeArrayOutput) +} + +type NetworkAreaNetworkRangeOutput struct{ *pulumi.OutputState } + +func (NetworkAreaNetworkRangeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*NetworkAreaNetworkRange)(nil)).Elem() +} + +func (o NetworkAreaNetworkRangeOutput) ToNetworkAreaNetworkRangeOutput() NetworkAreaNetworkRangeOutput { + return o +} + +func (o NetworkAreaNetworkRangeOutput) ToNetworkAreaNetworkRangeOutputWithContext(ctx context.Context) NetworkAreaNetworkRangeOutput { + return o +} + +func (o NetworkAreaNetworkRangeOutput) NetworkRangeId() pulumi.StringPtrOutput { + return o.ApplyT(func(v NetworkAreaNetworkRange) *string { return v.NetworkRangeId }).(pulumi.StringPtrOutput) +} + +// Classless Inter-Domain Routing (CIDR). +func (o NetworkAreaNetworkRangeOutput) Prefix() pulumi.StringOutput { + return o.ApplyT(func(v NetworkAreaNetworkRange) string { return v.Prefix }).(pulumi.StringOutput) +} + +type NetworkAreaNetworkRangeArrayOutput struct{ *pulumi.OutputState } + +func (NetworkAreaNetworkRangeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]NetworkAreaNetworkRange)(nil)).Elem() +} + +func (o NetworkAreaNetworkRangeArrayOutput) ToNetworkAreaNetworkRangeArrayOutput() NetworkAreaNetworkRangeArrayOutput { + return o +} + +func (o NetworkAreaNetworkRangeArrayOutput) ToNetworkAreaNetworkRangeArrayOutputWithContext(ctx context.Context) NetworkAreaNetworkRangeArrayOutput { + return o +} + +func (o NetworkAreaNetworkRangeArrayOutput) Index(i pulumi.IntInput) NetworkAreaNetworkRangeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) NetworkAreaNetworkRange { + return vs[0].([]NetworkAreaNetworkRange)[vs[1].(int)] + }).(NetworkAreaNetworkRangeOutput) +} + +type ObservabilityAlertgroupRule struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert string `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations map[string]string `pulumi:"annotations"` + // The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression string `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For *string `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels map[string]string `pulumi:"labels"` +} + +// ObservabilityAlertgroupRuleInput is an input type that accepts ObservabilityAlertgroupRuleArgs and ObservabilityAlertgroupRuleOutput values. +// You can construct a concrete instance of `ObservabilityAlertgroupRuleInput` via: +// +// ObservabilityAlertgroupRuleArgs{...} +type ObservabilityAlertgroupRuleInput interface { + pulumi.Input + + ToObservabilityAlertgroupRuleOutput() ObservabilityAlertgroupRuleOutput + ToObservabilityAlertgroupRuleOutputWithContext(context.Context) ObservabilityAlertgroupRuleOutput +} + +type ObservabilityAlertgroupRuleArgs struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert pulumi.StringInput `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression pulumi.StringInput `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For pulumi.StringPtrInput `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (ObservabilityAlertgroupRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityAlertgroupRule)(nil)).Elem() +} + +func (i ObservabilityAlertgroupRuleArgs) ToObservabilityAlertgroupRuleOutput() ObservabilityAlertgroupRuleOutput { + return i.ToObservabilityAlertgroupRuleOutputWithContext(context.Background()) +} + +func (i ObservabilityAlertgroupRuleArgs) ToObservabilityAlertgroupRuleOutputWithContext(ctx context.Context) ObservabilityAlertgroupRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityAlertgroupRuleOutput) +} + +// ObservabilityAlertgroupRuleArrayInput is an input type that accepts ObservabilityAlertgroupRuleArray and ObservabilityAlertgroupRuleArrayOutput values. +// You can construct a concrete instance of `ObservabilityAlertgroupRuleArrayInput` via: +// +// ObservabilityAlertgroupRuleArray{ ObservabilityAlertgroupRuleArgs{...} } +type ObservabilityAlertgroupRuleArrayInput interface { + pulumi.Input + + ToObservabilityAlertgroupRuleArrayOutput() ObservabilityAlertgroupRuleArrayOutput + ToObservabilityAlertgroupRuleArrayOutputWithContext(context.Context) ObservabilityAlertgroupRuleArrayOutput +} + +type ObservabilityAlertgroupRuleArray []ObservabilityAlertgroupRuleInput + +func (ObservabilityAlertgroupRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityAlertgroupRule)(nil)).Elem() +} + +func (i ObservabilityAlertgroupRuleArray) ToObservabilityAlertgroupRuleArrayOutput() ObservabilityAlertgroupRuleArrayOutput { + return i.ToObservabilityAlertgroupRuleArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityAlertgroupRuleArray) ToObservabilityAlertgroupRuleArrayOutputWithContext(ctx context.Context) ObservabilityAlertgroupRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityAlertgroupRuleArrayOutput) +} + +type ObservabilityAlertgroupRuleOutput struct{ *pulumi.OutputState } + +func (ObservabilityAlertgroupRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityAlertgroupRule)(nil)).Elem() +} + +func (o ObservabilityAlertgroupRuleOutput) ToObservabilityAlertgroupRuleOutput() ObservabilityAlertgroupRuleOutput { + return o +} + +func (o ObservabilityAlertgroupRuleOutput) ToObservabilityAlertgroupRuleOutputWithContext(ctx context.Context) ObservabilityAlertgroupRuleOutput { + return o +} + +// The name of the alert rule. Is the identifier and must be unique in the group. +func (o ObservabilityAlertgroupRuleOutput) Alert() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityAlertgroupRule) string { return v.Alert }).(pulumi.StringOutput) +} + +// A map of key:value. Annotations to add or overwrite for each alert +func (o ObservabilityAlertgroupRuleOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityAlertgroupRule) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. +func (o ObservabilityAlertgroupRuleOutput) Expression() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityAlertgroupRule) string { return v.Expression }).(pulumi.StringOutput) +} + +// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s +func (o ObservabilityAlertgroupRuleOutput) For() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityAlertgroupRule) *string { return v.For }).(pulumi.StringPtrOutput) +} + +// A map of key:value. Labels to add or overwrite for each alert +func (o ObservabilityAlertgroupRuleOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityAlertgroupRule) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type ObservabilityAlertgroupRuleArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityAlertgroupRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityAlertgroupRule)(nil)).Elem() +} + +func (o ObservabilityAlertgroupRuleArrayOutput) ToObservabilityAlertgroupRuleArrayOutput() ObservabilityAlertgroupRuleArrayOutput { + return o +} + +func (o ObservabilityAlertgroupRuleArrayOutput) ToObservabilityAlertgroupRuleArrayOutputWithContext(ctx context.Context) ObservabilityAlertgroupRuleArrayOutput { + return o +} + +func (o ObservabilityAlertgroupRuleArrayOutput) Index(i pulumi.IntInput) ObservabilityAlertgroupRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityAlertgroupRule { + return vs[0].([]ObservabilityAlertgroupRule)[vs[1].(int)] + }).(ObservabilityAlertgroupRuleOutput) +} + +type ObservabilityInstanceAlertConfig struct { + // Global configuration for the alerts. + Global *ObservabilityInstanceAlertConfigGlobal `pulumi:"global"` + // List of alert receivers. + Receivers []ObservabilityInstanceAlertConfigReceiver `pulumi:"receivers"` + // Route configuration for the alerts. + Route ObservabilityInstanceAlertConfigRoute `pulumi:"route"` +} + +// ObservabilityInstanceAlertConfigInput is an input type that accepts ObservabilityInstanceAlertConfigArgs and ObservabilityInstanceAlertConfigOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigInput` via: +// +// ObservabilityInstanceAlertConfigArgs{...} +type ObservabilityInstanceAlertConfigInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigOutput() ObservabilityInstanceAlertConfigOutput + ToObservabilityInstanceAlertConfigOutputWithContext(context.Context) ObservabilityInstanceAlertConfigOutput +} + +type ObservabilityInstanceAlertConfigArgs struct { + // Global configuration for the alerts. + Global ObservabilityInstanceAlertConfigGlobalPtrInput `pulumi:"global"` + // List of alert receivers. + Receivers ObservabilityInstanceAlertConfigReceiverArrayInput `pulumi:"receivers"` + // Route configuration for the alerts. + Route ObservabilityInstanceAlertConfigRouteInput `pulumi:"route"` +} + +func (ObservabilityInstanceAlertConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigArgs) ToObservabilityInstanceAlertConfigOutput() ObservabilityInstanceAlertConfigOutput { + return i.ToObservabilityInstanceAlertConfigOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigArgs) ToObservabilityInstanceAlertConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigOutput) +} + +func (i ObservabilityInstanceAlertConfigArgs) ToObservabilityInstanceAlertConfigPtrOutput() ObservabilityInstanceAlertConfigPtrOutput { + return i.ToObservabilityInstanceAlertConfigPtrOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigArgs) ToObservabilityInstanceAlertConfigPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigOutput).ToObservabilityInstanceAlertConfigPtrOutputWithContext(ctx) +} + +// ObservabilityInstanceAlertConfigPtrInput is an input type that accepts ObservabilityInstanceAlertConfigArgs, ObservabilityInstanceAlertConfigPtr and ObservabilityInstanceAlertConfigPtrOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigPtrInput` via: +// +// ObservabilityInstanceAlertConfigArgs{...} +// +// or: +// +// nil +type ObservabilityInstanceAlertConfigPtrInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigPtrOutput() ObservabilityInstanceAlertConfigPtrOutput + ToObservabilityInstanceAlertConfigPtrOutputWithContext(context.Context) ObservabilityInstanceAlertConfigPtrOutput +} + +type observabilityInstanceAlertConfigPtrType ObservabilityInstanceAlertConfigArgs + +func ObservabilityInstanceAlertConfigPtr(v *ObservabilityInstanceAlertConfigArgs) ObservabilityInstanceAlertConfigPtrInput { + return (*observabilityInstanceAlertConfigPtrType)(v) +} + +func (*observabilityInstanceAlertConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (i *observabilityInstanceAlertConfigPtrType) ToObservabilityInstanceAlertConfigPtrOutput() ObservabilityInstanceAlertConfigPtrOutput { + return i.ToObservabilityInstanceAlertConfigPtrOutputWithContext(context.Background()) +} + +func (i *observabilityInstanceAlertConfigPtrType) ToObservabilityInstanceAlertConfigPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigPtrOutput) +} + +type ObservabilityInstanceAlertConfigOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigOutput) ToObservabilityInstanceAlertConfigOutput() ObservabilityInstanceAlertConfigOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigOutput) ToObservabilityInstanceAlertConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigOutput) ToObservabilityInstanceAlertConfigPtrOutput() ObservabilityInstanceAlertConfigPtrOutput { + return o.ToObservabilityInstanceAlertConfigPtrOutputWithContext(context.Background()) +} + +func (o ObservabilityInstanceAlertConfigOutput) ToObservabilityInstanceAlertConfigPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityInstanceAlertConfig) *ObservabilityInstanceAlertConfig { + return &v + }).(ObservabilityInstanceAlertConfigPtrOutput) +} + +// Global configuration for the alerts. +func (o ObservabilityInstanceAlertConfigOutput) Global() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfig) *ObservabilityInstanceAlertConfigGlobal { return v.Global }).(ObservabilityInstanceAlertConfigGlobalPtrOutput) +} + +// List of alert receivers. +func (o ObservabilityInstanceAlertConfigOutput) Receivers() ObservabilityInstanceAlertConfigReceiverArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfig) []ObservabilityInstanceAlertConfigReceiver { + return v.Receivers + }).(ObservabilityInstanceAlertConfigReceiverArrayOutput) +} + +// Route configuration for the alerts. +func (o ObservabilityInstanceAlertConfigOutput) Route() ObservabilityInstanceAlertConfigRouteOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfig) ObservabilityInstanceAlertConfigRoute { return v.Route }).(ObservabilityInstanceAlertConfigRouteOutput) +} + +type ObservabilityInstanceAlertConfigPtrOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigPtrOutput) ToObservabilityInstanceAlertConfigPtrOutput() ObservabilityInstanceAlertConfigPtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigPtrOutput) ToObservabilityInstanceAlertConfigPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigPtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigPtrOutput) Elem() ObservabilityInstanceAlertConfigOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfig) ObservabilityInstanceAlertConfig { + if v != nil { + return *v + } + var ret ObservabilityInstanceAlertConfig + return ret + }).(ObservabilityInstanceAlertConfigOutput) +} + +// Global configuration for the alerts. +func (o ObservabilityInstanceAlertConfigPtrOutput) Global() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfig) *ObservabilityInstanceAlertConfigGlobal { + if v == nil { + return nil + } + return v.Global + }).(ObservabilityInstanceAlertConfigGlobalPtrOutput) +} + +// List of alert receivers. +func (o ObservabilityInstanceAlertConfigPtrOutput) Receivers() ObservabilityInstanceAlertConfigReceiverArrayOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfig) []ObservabilityInstanceAlertConfigReceiver { + if v == nil { + return nil + } + return v.Receivers + }).(ObservabilityInstanceAlertConfigReceiverArrayOutput) +} + +// Route configuration for the alerts. +func (o ObservabilityInstanceAlertConfigPtrOutput) Route() ObservabilityInstanceAlertConfigRoutePtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfig) *ObservabilityInstanceAlertConfigRoute { + if v == nil { + return nil + } + return &v.Route + }).(ObservabilityInstanceAlertConfigRoutePtrOutput) +} + +type ObservabilityInstanceAlertConfigGlobal struct { + // The API key for OpsGenie. + OpsgenieApiKey *string `pulumi:"opsgenieApiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + OpsgenieApiUrl *string `pulumi:"opsgenieApiUrl"` + // The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + ResolveTimeout *string `pulumi:"resolveTimeout"` + // SMTP authentication information. Must be a valid email address + SmtpAuthIdentity *string `pulumi:"smtpAuthIdentity"` + // SMTP Auth using LOGIN and PLAIN. + SmtpAuthPassword *string `pulumi:"smtpAuthPassword"` + // SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + SmtpAuthUsername *string `pulumi:"smtpAuthUsername"` + // The default SMTP From header field. Must be a valid email address + SmtpFrom *string `pulumi:"smtpFrom"` + // The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + SmtpSmartHost *string `pulumi:"smtpSmartHost"` +} + +// ObservabilityInstanceAlertConfigGlobalInput is an input type that accepts ObservabilityInstanceAlertConfigGlobalArgs and ObservabilityInstanceAlertConfigGlobalOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigGlobalInput` via: +// +// ObservabilityInstanceAlertConfigGlobalArgs{...} +type ObservabilityInstanceAlertConfigGlobalInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigGlobalOutput() ObservabilityInstanceAlertConfigGlobalOutput + ToObservabilityInstanceAlertConfigGlobalOutputWithContext(context.Context) ObservabilityInstanceAlertConfigGlobalOutput +} + +type ObservabilityInstanceAlertConfigGlobalArgs struct { + // The API key for OpsGenie. + OpsgenieApiKey pulumi.StringPtrInput `pulumi:"opsgenieApiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + OpsgenieApiUrl pulumi.StringPtrInput `pulumi:"opsgenieApiUrl"` + // The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + ResolveTimeout pulumi.StringPtrInput `pulumi:"resolveTimeout"` + // SMTP authentication information. Must be a valid email address + SmtpAuthIdentity pulumi.StringPtrInput `pulumi:"smtpAuthIdentity"` + // SMTP Auth using LOGIN and PLAIN. + SmtpAuthPassword pulumi.StringPtrInput `pulumi:"smtpAuthPassword"` + // SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + SmtpAuthUsername pulumi.StringPtrInput `pulumi:"smtpAuthUsername"` + // The default SMTP From header field. Must be a valid email address + SmtpFrom pulumi.StringPtrInput `pulumi:"smtpFrom"` + // The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + SmtpSmartHost pulumi.StringPtrInput `pulumi:"smtpSmartHost"` +} + +func (ObservabilityInstanceAlertConfigGlobalArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigGlobalArgs) ToObservabilityInstanceAlertConfigGlobalOutput() ObservabilityInstanceAlertConfigGlobalOutput { + return i.ToObservabilityInstanceAlertConfigGlobalOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigGlobalArgs) ToObservabilityInstanceAlertConfigGlobalOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigGlobalOutput) +} + +func (i ObservabilityInstanceAlertConfigGlobalArgs) ToObservabilityInstanceAlertConfigGlobalPtrOutput() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return i.ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigGlobalArgs) ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigGlobalOutput).ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(ctx) +} + +// ObservabilityInstanceAlertConfigGlobalPtrInput is an input type that accepts ObservabilityInstanceAlertConfigGlobalArgs, ObservabilityInstanceAlertConfigGlobalPtr and ObservabilityInstanceAlertConfigGlobalPtrOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigGlobalPtrInput` via: +// +// ObservabilityInstanceAlertConfigGlobalArgs{...} +// +// or: +// +// nil +type ObservabilityInstanceAlertConfigGlobalPtrInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigGlobalPtrOutput() ObservabilityInstanceAlertConfigGlobalPtrOutput + ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(context.Context) ObservabilityInstanceAlertConfigGlobalPtrOutput +} + +type observabilityInstanceAlertConfigGlobalPtrType ObservabilityInstanceAlertConfigGlobalArgs + +func ObservabilityInstanceAlertConfigGlobalPtr(v *ObservabilityInstanceAlertConfigGlobalArgs) ObservabilityInstanceAlertConfigGlobalPtrInput { + return (*observabilityInstanceAlertConfigGlobalPtrType)(v) +} + +func (*observabilityInstanceAlertConfigGlobalPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (i *observabilityInstanceAlertConfigGlobalPtrType) ToObservabilityInstanceAlertConfigGlobalPtrOutput() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return i.ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(context.Background()) +} + +func (i *observabilityInstanceAlertConfigGlobalPtrType) ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigGlobalPtrOutput) +} + +type ObservabilityInstanceAlertConfigGlobalOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigGlobalOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigGlobalOutput) ToObservabilityInstanceAlertConfigGlobalOutput() ObservabilityInstanceAlertConfigGlobalOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigGlobalOutput) ToObservabilityInstanceAlertConfigGlobalOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigGlobalOutput) ToObservabilityInstanceAlertConfigGlobalPtrOutput() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o.ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(context.Background()) +} + +func (o ObservabilityInstanceAlertConfigGlobalOutput) ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityInstanceAlertConfigGlobal) *ObservabilityInstanceAlertConfigGlobal { + return &v + }).(ObservabilityInstanceAlertConfigGlobalPtrOutput) +} + +// The API key for OpsGenie. +func (o ObservabilityInstanceAlertConfigGlobalOutput) OpsgenieApiKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.OpsgenieApiKey }).(pulumi.StringPtrOutput) +} + +// The host to send OpsGenie API requests to. Must be a valid URL +func (o ObservabilityInstanceAlertConfigGlobalOutput) OpsgenieApiUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.OpsgenieApiUrl }).(pulumi.StringPtrOutput) +} + +// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. +func (o ObservabilityInstanceAlertConfigGlobalOutput) ResolveTimeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.ResolveTimeout }).(pulumi.StringPtrOutput) +} + +// SMTP authentication information. Must be a valid email address +func (o ObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthIdentity() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.SmtpAuthIdentity }).(pulumi.StringPtrOutput) +} + +// SMTP Auth using LOGIN and PLAIN. +func (o ObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthPassword() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.SmtpAuthPassword }).(pulumi.StringPtrOutput) +} + +// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. +func (o ObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthUsername() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.SmtpAuthUsername }).(pulumi.StringPtrOutput) +} + +// The default SMTP From header field. Must be a valid email address +func (o ObservabilityInstanceAlertConfigGlobalOutput) SmtpFrom() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.SmtpFrom }).(pulumi.StringPtrOutput) +} + +// The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). +func (o ObservabilityInstanceAlertConfigGlobalOutput) SmtpSmartHost() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigGlobal) *string { return v.SmtpSmartHost }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigGlobalPtrOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigGlobalPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) ToObservabilityInstanceAlertConfigGlobalPtrOutput() ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) ToObservabilityInstanceAlertConfigGlobalPtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigGlobalPtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) Elem() ObservabilityInstanceAlertConfigGlobalOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) ObservabilityInstanceAlertConfigGlobal { + if v != nil { + return *v + } + var ret ObservabilityInstanceAlertConfigGlobal + return ret + }).(ObservabilityInstanceAlertConfigGlobalOutput) +} + +// The API key for OpsGenie. +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) OpsgenieApiKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.OpsgenieApiKey + }).(pulumi.StringPtrOutput) +} + +// The host to send OpsGenie API requests to. Must be a valid URL +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) OpsgenieApiUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.OpsgenieApiUrl + }).(pulumi.StringPtrOutput) +} + +// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) ResolveTimeout() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.ResolveTimeout + }).(pulumi.StringPtrOutput) +} + +// SMTP authentication information. Must be a valid email address +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) SmtpAuthIdentity() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.SmtpAuthIdentity + }).(pulumi.StringPtrOutput) +} + +// SMTP Auth using LOGIN and PLAIN. +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) SmtpAuthPassword() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.SmtpAuthPassword + }).(pulumi.StringPtrOutput) +} + +// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) SmtpAuthUsername() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.SmtpAuthUsername + }).(pulumi.StringPtrOutput) +} + +// The default SMTP From header field. Must be a valid email address +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) SmtpFrom() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.SmtpFrom + }).(pulumi.StringPtrOutput) +} + +// The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). +func (o ObservabilityInstanceAlertConfigGlobalPtrOutput) SmtpSmartHost() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigGlobal) *string { + if v == nil { + return nil + } + return v.SmtpSmartHost + }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigReceiver struct { + // List of email configurations. + EmailConfigs []ObservabilityInstanceAlertConfigReceiverEmailConfig `pulumi:"emailConfigs"` + // Name of the receiver. + Name string `pulumi:"name"` + // List of OpsGenie configurations. + OpsgenieConfigs []ObservabilityInstanceAlertConfigReceiverOpsgenieConfig `pulumi:"opsgenieConfigs"` + // List of Webhooks configurations. + WebhooksConfigs []ObservabilityInstanceAlertConfigReceiverWebhooksConfig `pulumi:"webhooksConfigs"` +} + +// ObservabilityInstanceAlertConfigReceiverInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverArgs and ObservabilityInstanceAlertConfigReceiverOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverInput` via: +// +// ObservabilityInstanceAlertConfigReceiverArgs{...} +type ObservabilityInstanceAlertConfigReceiverInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverOutput() ObservabilityInstanceAlertConfigReceiverOutput + ToObservabilityInstanceAlertConfigReceiverOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverOutput +} + +type ObservabilityInstanceAlertConfigReceiverArgs struct { + // List of email configurations. + EmailConfigs ObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput `pulumi:"emailConfigs"` + // Name of the receiver. + Name pulumi.StringInput `pulumi:"name"` + // List of OpsGenie configurations. + OpsgenieConfigs ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput `pulumi:"opsgenieConfigs"` + // List of Webhooks configurations. + WebhooksConfigs ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput `pulumi:"webhooksConfigs"` +} + +func (ObservabilityInstanceAlertConfigReceiverArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverArgs) ToObservabilityInstanceAlertConfigReceiverOutput() ObservabilityInstanceAlertConfigReceiverOutput { + return i.ToObservabilityInstanceAlertConfigReceiverOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverArgs) ToObservabilityInstanceAlertConfigReceiverOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverOutput) +} + +// ObservabilityInstanceAlertConfigReceiverArrayInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverArray and ObservabilityInstanceAlertConfigReceiverArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverArrayInput` via: +// +// ObservabilityInstanceAlertConfigReceiverArray{ ObservabilityInstanceAlertConfigReceiverArgs{...} } +type ObservabilityInstanceAlertConfigReceiverArrayInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverArrayOutput() ObservabilityInstanceAlertConfigReceiverArrayOutput + ToObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverArrayOutput +} + +type ObservabilityInstanceAlertConfigReceiverArray []ObservabilityInstanceAlertConfigReceiverInput + +func (ObservabilityInstanceAlertConfigReceiverArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverArray) ToObservabilityInstanceAlertConfigReceiverArrayOutput() ObservabilityInstanceAlertConfigReceiverArrayOutput { + return i.ToObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverArray) ToObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverArrayOutput) +} + +type ObservabilityInstanceAlertConfigReceiverOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverOutput) ToObservabilityInstanceAlertConfigReceiverOutput() ObservabilityInstanceAlertConfigReceiverOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverOutput) ToObservabilityInstanceAlertConfigReceiverOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOutput { + return o +} + +// List of email configurations. +func (o ObservabilityInstanceAlertConfigReceiverOutput) EmailConfigs() ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiver) []ObservabilityInstanceAlertConfigReceiverEmailConfig { + return v.EmailConfigs + }).(ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) +} + +// Name of the receiver. +func (o ObservabilityInstanceAlertConfigReceiverOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiver) string { return v.Name }).(pulumi.StringOutput) +} + +// List of OpsGenie configurations. +func (o ObservabilityInstanceAlertConfigReceiverOutput) OpsgenieConfigs() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiver) []ObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + return v.OpsgenieConfigs + }).(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) +} + +// List of Webhooks configurations. +func (o ObservabilityInstanceAlertConfigReceiverOutput) WebhooksConfigs() ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiver) []ObservabilityInstanceAlertConfigReceiverWebhooksConfig { + return v.WebhooksConfigs + }).(ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) +} + +type ObservabilityInstanceAlertConfigReceiverArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverArrayOutput) ToObservabilityInstanceAlertConfigReceiverArrayOutput() ObservabilityInstanceAlertConfigReceiverArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverArrayOutput) ToObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceAlertConfigReceiverOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityInstanceAlertConfigReceiver { + return vs[0].([]ObservabilityInstanceAlertConfigReceiver)[vs[1].(int)] + }).(ObservabilityInstanceAlertConfigReceiverOutput) +} + +type ObservabilityInstanceAlertConfigReceiverEmailConfig struct { + // SMTP authentication information. Must be a valid email address + AuthIdentity *string `pulumi:"authIdentity"` + // SMTP authentication password. + AuthPassword *string `pulumi:"authPassword"` + // SMTP authentication username. + AuthUsername *string `pulumi:"authUsername"` + // The sender email address. Must be a valid email address + From *string `pulumi:"from"` + // The SMTP host through which emails are sent. + SmartHost *string `pulumi:"smartHost"` + // The email address to send notifications to. Must be a valid email address + To *string `pulumi:"to"` +} + +// ObservabilityInstanceAlertConfigReceiverEmailConfigInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverEmailConfigArgs and ObservabilityInstanceAlertConfigReceiverEmailConfigOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverEmailConfigInput` via: +// +// ObservabilityInstanceAlertConfigReceiverEmailConfigArgs{...} +type ObservabilityInstanceAlertConfigReceiverEmailConfigInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverEmailConfigOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigOutput + ToObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigOutput +} + +type ObservabilityInstanceAlertConfigReceiverEmailConfigArgs struct { + // SMTP authentication information. Must be a valid email address + AuthIdentity pulumi.StringPtrInput `pulumi:"authIdentity"` + // SMTP authentication password. + AuthPassword pulumi.StringPtrInput `pulumi:"authPassword"` + // SMTP authentication username. + AuthUsername pulumi.StringPtrInput `pulumi:"authUsername"` + // The sender email address. Must be a valid email address + From pulumi.StringPtrInput `pulumi:"from"` + // The SMTP host through which emails are sent. + SmartHost pulumi.StringPtrInput `pulumi:"smartHost"` + // The email address to send notifications to. Must be a valid email address + To pulumi.StringPtrInput `pulumi:"to"` +} + +func (ObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ToObservabilityInstanceAlertConfigReceiverEmailConfigOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return i.ToObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ToObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) +} + +// ObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverEmailConfigArray and ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput` via: +// +// ObservabilityInstanceAlertConfigReceiverEmailConfigArray{ ObservabilityInstanceAlertConfigReceiverEmailConfigArgs{...} } +type ObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput + ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput +} + +type ObservabilityInstanceAlertConfigReceiverEmailConfigArray []ObservabilityInstanceAlertConfigReceiverEmailConfigInput + +func (ObservabilityInstanceAlertConfigReceiverEmailConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverEmailConfigArray) ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return i.ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverEmailConfigArray) ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) +} + +type ObservabilityInstanceAlertConfigReceiverEmailConfigOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ToObservabilityInstanceAlertConfigReceiverEmailConfigOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ToObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return o +} + +// SMTP authentication information. Must be a valid email address +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthIdentity() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.AuthIdentity }).(pulumi.StringPtrOutput) +} + +// SMTP authentication password. +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthPassword() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.AuthPassword }).(pulumi.StringPtrOutput) +} + +// SMTP authentication username. +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthUsername() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.AuthUsername }).(pulumi.StringPtrOutput) +} + +// The sender email address. Must be a valid email address +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) From() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.From }).(pulumi.StringPtrOutput) +} + +// The SMTP host through which emails are sent. +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) SmartHost() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.SmartHost }).(pulumi.StringPtrOutput) +} + +// The email address to send notifications to. Must be a valid email address +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) To() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverEmailConfig) *string { return v.To }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityInstanceAlertConfigReceiverEmailConfig { + return vs[0].([]ObservabilityInstanceAlertConfigReceiverEmailConfig)[vs[1].(int)] + }).(ObservabilityInstanceAlertConfigReceiverEmailConfigOutput) +} + +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfig struct { + // The API key for OpsGenie. + ApiKey *string `pulumi:"apiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + ApiUrl *string `pulumi:"apiUrl"` + // Comma separated list of tags attached to the notifications. + Tags *string `pulumi:"tags"` +} + +// ObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs and ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput` via: +// +// ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{...} +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput + ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput +} + +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs struct { + // The API key for OpsGenie. + ApiKey pulumi.StringPtrInput `pulumi:"apiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + ApiUrl pulumi.StringPtrInput `pulumi:"apiUrl"` + // Comma separated list of tags attached to the notifications. + Tags pulumi.StringPtrInput `pulumi:"tags"` +} + +func (ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return i.ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) +} + +// ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray and ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput` via: +// +// ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray{ ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{...} } +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput + ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput +} + +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray []ObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput + +func (ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return i.ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) +} + +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return o +} + +// The API key for OpsGenie. +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ApiKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverOpsgenieConfig) *string { return v.ApiKey }).(pulumi.StringPtrOutput) +} + +// The host to send OpsGenie API requests to. Must be a valid URL +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ApiUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverOpsgenieConfig) *string { return v.ApiUrl }).(pulumi.StringPtrOutput) +} + +// Comma separated list of tags attached to the notifications. +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) Tags() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverOpsgenieConfig) *string { return v.Tags }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + return vs[0].([]ObservabilityInstanceAlertConfigReceiverOpsgenieConfig)[vs[1].(int)] + }).(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) +} + +type ObservabilityInstanceAlertConfigReceiverWebhooksConfig struct { + // Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + MsTeams *bool `pulumi:"msTeams"` + // The endpoint to send HTTP POST requests to. Must be a valid URL + Url *string `pulumi:"url"` +} + +// ObservabilityInstanceAlertConfigReceiverWebhooksConfigInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs and ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverWebhooksConfigInput` via: +// +// ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{...} +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput + ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput +} + +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs struct { + // Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + MsTeams pulumi.BoolPtrInput `pulumi:"msTeams"` + // The endpoint to send HTTP POST requests to. Must be a valid URL + Url pulumi.StringPtrInput `pulumi:"url"` +} + +func (ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return i.ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) +} + +// ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput is an input type that accepts ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray and ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput` via: +// +// ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray{ ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{...} } +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput + ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput +} + +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray []ObservabilityInstanceAlertConfigReceiverWebhooksConfigInput + +func (ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return i.ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) +} + +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return o +} + +// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) MsTeams() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverWebhooksConfig) *bool { return v.MsTeams }).(pulumi.BoolPtrOutput) +} + +// The endpoint to send HTTP POST requests to. Must be a valid URL +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigReceiverWebhooksConfig) *string { return v.Url }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ToObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityInstanceAlertConfigReceiverWebhooksConfig { + return vs[0].([]ObservabilityInstanceAlertConfigReceiverWebhooksConfig)[vs[1].(int)] + }).(ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) +} + +type ObservabilityInstanceAlertConfigRoute struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies []string `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval *string `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait *string `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match map[string]string `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex map[string]string `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver string `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval *string `pulumi:"repeatInterval"` + // List of child routes. + Routes []ObservabilityInstanceAlertConfigRouteRoute `pulumi:"routes"` +} + +// ObservabilityInstanceAlertConfigRouteInput is an input type that accepts ObservabilityInstanceAlertConfigRouteArgs and ObservabilityInstanceAlertConfigRouteOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigRouteInput` via: +// +// ObservabilityInstanceAlertConfigRouteArgs{...} +type ObservabilityInstanceAlertConfigRouteInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigRouteOutput() ObservabilityInstanceAlertConfigRouteOutput + ToObservabilityInstanceAlertConfigRouteOutputWithContext(context.Context) ObservabilityInstanceAlertConfigRouteOutput +} + +type ObservabilityInstanceAlertConfigRouteArgs struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies pulumi.StringArrayInput `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval pulumi.StringPtrInput `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait pulumi.StringPtrInput `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match pulumi.StringMapInput `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex pulumi.StringMapInput `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver pulumi.StringInput `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval pulumi.StringPtrInput `pulumi:"repeatInterval"` + // List of child routes. + Routes ObservabilityInstanceAlertConfigRouteRouteArrayInput `pulumi:"routes"` +} + +func (ObservabilityInstanceAlertConfigRouteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigRouteArgs) ToObservabilityInstanceAlertConfigRouteOutput() ObservabilityInstanceAlertConfigRouteOutput { + return i.ToObservabilityInstanceAlertConfigRouteOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigRouteArgs) ToObservabilityInstanceAlertConfigRouteOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigRouteOutput) +} + +func (i ObservabilityInstanceAlertConfigRouteArgs) ToObservabilityInstanceAlertConfigRoutePtrOutput() ObservabilityInstanceAlertConfigRoutePtrOutput { + return i.ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigRouteArgs) ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRoutePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigRouteOutput).ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(ctx) +} + +// ObservabilityInstanceAlertConfigRoutePtrInput is an input type that accepts ObservabilityInstanceAlertConfigRouteArgs, ObservabilityInstanceAlertConfigRoutePtr and ObservabilityInstanceAlertConfigRoutePtrOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigRoutePtrInput` via: +// +// ObservabilityInstanceAlertConfigRouteArgs{...} +// +// or: +// +// nil +type ObservabilityInstanceAlertConfigRoutePtrInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigRoutePtrOutput() ObservabilityInstanceAlertConfigRoutePtrOutput + ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(context.Context) ObservabilityInstanceAlertConfigRoutePtrOutput +} + +type observabilityInstanceAlertConfigRoutePtrType ObservabilityInstanceAlertConfigRouteArgs + +func ObservabilityInstanceAlertConfigRoutePtr(v *ObservabilityInstanceAlertConfigRouteArgs) ObservabilityInstanceAlertConfigRoutePtrInput { + return (*observabilityInstanceAlertConfigRoutePtrType)(v) +} + +func (*observabilityInstanceAlertConfigRoutePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (i *observabilityInstanceAlertConfigRoutePtrType) ToObservabilityInstanceAlertConfigRoutePtrOutput() ObservabilityInstanceAlertConfigRoutePtrOutput { + return i.ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(context.Background()) +} + +func (i *observabilityInstanceAlertConfigRoutePtrType) ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRoutePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigRoutePtrOutput) +} + +type ObservabilityInstanceAlertConfigRouteOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigRouteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigRouteOutput) ToObservabilityInstanceAlertConfigRouteOutput() ObservabilityInstanceAlertConfigRouteOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRouteOutput) ToObservabilityInstanceAlertConfigRouteOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRouteOutput) ToObservabilityInstanceAlertConfigRoutePtrOutput() ObservabilityInstanceAlertConfigRoutePtrOutput { + return o.ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(context.Background()) +} + +func (o ObservabilityInstanceAlertConfigRouteOutput) ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRoutePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityInstanceAlertConfigRoute) *ObservabilityInstanceAlertConfigRoute { + return &v + }).(ObservabilityInstanceAlertConfigRoutePtrOutput) +} + +// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. +func (o ObservabilityInstanceAlertConfigRouteOutput) GroupBies() pulumi.StringArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) []string { return v.GroupBies }).(pulumi.StringArrayOutput) +} + +// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) +func (o ObservabilityInstanceAlertConfigRouteOutput) GroupInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) *string { return v.GroupInterval }).(pulumi.StringPtrOutput) +} + +// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) +func (o ObservabilityInstanceAlertConfigRouteOutput) GroupWait() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) *string { return v.GroupWait }).(pulumi.StringPtrOutput) +} + +// A set of equality matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRouteOutput) Match() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) map[string]string { return v.Match }).(pulumi.StringMapOutput) +} + +// A set of regex-matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRouteOutput) MatchRegex() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) map[string]string { return v.MatchRegex }).(pulumi.StringMapOutput) +} + +// The name of the receiver to route the alerts to. +func (o ObservabilityInstanceAlertConfigRouteOutput) Receiver() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) string { return v.Receiver }).(pulumi.StringOutput) +} + +// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). +func (o ObservabilityInstanceAlertConfigRouteOutput) RepeatInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) *string { return v.RepeatInterval }).(pulumi.StringPtrOutput) +} + +// List of child routes. +func (o ObservabilityInstanceAlertConfigRouteOutput) Routes() ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRoute) []ObservabilityInstanceAlertConfigRouteRoute { + return v.Routes + }).(ObservabilityInstanceAlertConfigRouteRouteArrayOutput) +} + +type ObservabilityInstanceAlertConfigRoutePtrOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigRoutePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) ToObservabilityInstanceAlertConfigRoutePtrOutput() ObservabilityInstanceAlertConfigRoutePtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) ToObservabilityInstanceAlertConfigRoutePtrOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRoutePtrOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) Elem() ObservabilityInstanceAlertConfigRouteOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) ObservabilityInstanceAlertConfigRoute { + if v != nil { + return *v + } + var ret ObservabilityInstanceAlertConfigRoute + return ret + }).(ObservabilityInstanceAlertConfigRouteOutput) +} + +// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) GroupBies() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) []string { + if v == nil { + return nil + } + return v.GroupBies + }).(pulumi.StringArrayOutput) +} + +// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) GroupInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) *string { + if v == nil { + return nil + } + return v.GroupInterval + }).(pulumi.StringPtrOutput) +} + +// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) GroupWait() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) *string { + if v == nil { + return nil + } + return v.GroupWait + }).(pulumi.StringPtrOutput) +} + +// A set of equality matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) Match() pulumi.StringMapOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) map[string]string { + if v == nil { + return nil + } + return v.Match + }).(pulumi.StringMapOutput) +} + +// A set of regex-matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) MatchRegex() pulumi.StringMapOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) map[string]string { + if v == nil { + return nil + } + return v.MatchRegex + }).(pulumi.StringMapOutput) +} + +// The name of the receiver to route the alerts to. +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) Receiver() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) *string { + if v == nil { + return nil + } + return &v.Receiver + }).(pulumi.StringPtrOutput) +} + +// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) RepeatInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) *string { + if v == nil { + return nil + } + return v.RepeatInterval + }).(pulumi.StringPtrOutput) +} + +// List of child routes. +func (o ObservabilityInstanceAlertConfigRoutePtrOutput) Routes() ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o.ApplyT(func(v *ObservabilityInstanceAlertConfigRoute) []ObservabilityInstanceAlertConfigRouteRoute { + if v == nil { + return nil + } + return v.Routes + }).(ObservabilityInstanceAlertConfigRouteRouteArrayOutput) +} + +type ObservabilityInstanceAlertConfigRouteRoute struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies []string `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval *string `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait *string `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match map[string]string `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex map[string]string `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver string `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval *string `pulumi:"repeatInterval"` +} + +// ObservabilityInstanceAlertConfigRouteRouteInput is an input type that accepts ObservabilityInstanceAlertConfigRouteRouteArgs and ObservabilityInstanceAlertConfigRouteRouteOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigRouteRouteInput` via: +// +// ObservabilityInstanceAlertConfigRouteRouteArgs{...} +type ObservabilityInstanceAlertConfigRouteRouteInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigRouteRouteOutput() ObservabilityInstanceAlertConfigRouteRouteOutput + ToObservabilityInstanceAlertConfigRouteRouteOutputWithContext(context.Context) ObservabilityInstanceAlertConfigRouteRouteOutput +} + +type ObservabilityInstanceAlertConfigRouteRouteArgs struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies pulumi.StringArrayInput `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval pulumi.StringPtrInput `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait pulumi.StringPtrInput `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match pulumi.StringMapInput `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex pulumi.StringMapInput `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver pulumi.StringInput `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval pulumi.StringPtrInput `pulumi:"repeatInterval"` +} + +func (ObservabilityInstanceAlertConfigRouteRouteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigRouteRouteArgs) ToObservabilityInstanceAlertConfigRouteRouteOutput() ObservabilityInstanceAlertConfigRouteRouteOutput { + return i.ToObservabilityInstanceAlertConfigRouteRouteOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigRouteRouteArgs) ToObservabilityInstanceAlertConfigRouteRouteOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteRouteOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigRouteRouteOutput) +} + +// ObservabilityInstanceAlertConfigRouteRouteArrayInput is an input type that accepts ObservabilityInstanceAlertConfigRouteRouteArray and ObservabilityInstanceAlertConfigRouteRouteArrayOutput values. +// You can construct a concrete instance of `ObservabilityInstanceAlertConfigRouteRouteArrayInput` via: +// +// ObservabilityInstanceAlertConfigRouteRouteArray{ ObservabilityInstanceAlertConfigRouteRouteArgs{...} } +type ObservabilityInstanceAlertConfigRouteRouteArrayInput interface { + pulumi.Input + + ToObservabilityInstanceAlertConfigRouteRouteArrayOutput() ObservabilityInstanceAlertConfigRouteRouteArrayOutput + ToObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(context.Context) ObservabilityInstanceAlertConfigRouteRouteArrayOutput +} + +type ObservabilityInstanceAlertConfigRouteRouteArray []ObservabilityInstanceAlertConfigRouteRouteInput + +func (ObservabilityInstanceAlertConfigRouteRouteArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (i ObservabilityInstanceAlertConfigRouteRouteArray) ToObservabilityInstanceAlertConfigRouteRouteArrayOutput() ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return i.ToObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityInstanceAlertConfigRouteRouteArray) ToObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityInstanceAlertConfigRouteRouteArrayOutput) +} + +type ObservabilityInstanceAlertConfigRouteRouteOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigRouteRouteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) ToObservabilityInstanceAlertConfigRouteRouteOutput() ObservabilityInstanceAlertConfigRouteRouteOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) ToObservabilityInstanceAlertConfigRouteRouteOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteRouteOutput { + return o +} + +// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) GroupBies() pulumi.StringArrayOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) []string { return v.GroupBies }).(pulumi.StringArrayOutput) +} + +// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) GroupInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) *string { return v.GroupInterval }).(pulumi.StringPtrOutput) +} + +// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) GroupWait() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) *string { return v.GroupWait }).(pulumi.StringPtrOutput) +} + +// A set of equality matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) Match() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) map[string]string { return v.Match }).(pulumi.StringMapOutput) +} + +// A set of regex-matchers an alert has to fulfill to match the node. +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) MatchRegex() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) map[string]string { return v.MatchRegex }).(pulumi.StringMapOutput) +} + +// The name of the receiver to route the alerts to. +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) Receiver() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) string { return v.Receiver }).(pulumi.StringOutput) +} + +// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). +func (o ObservabilityInstanceAlertConfigRouteRouteOutput) RepeatInterval() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityInstanceAlertConfigRouteRoute) *string { return v.RepeatInterval }).(pulumi.StringPtrOutput) +} + +type ObservabilityInstanceAlertConfigRouteRouteArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityInstanceAlertConfigRouteRouteArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (o ObservabilityInstanceAlertConfigRouteRouteArrayOutput) ToObservabilityInstanceAlertConfigRouteRouteArrayOutput() ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRouteRouteArrayOutput) ToObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(ctx context.Context) ObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o +} + +func (o ObservabilityInstanceAlertConfigRouteRouteArrayOutput) Index(i pulumi.IntInput) ObservabilityInstanceAlertConfigRouteRouteOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityInstanceAlertConfigRouteRoute { + return vs[0].([]ObservabilityInstanceAlertConfigRouteRoute)[vs[1].(int)] + }).(ObservabilityInstanceAlertConfigRouteRouteOutput) +} + +type ObservabilityLogalertgroupRule struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert string `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations map[string]string `pulumi:"annotations"` + // The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression string `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For *string `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels map[string]string `pulumi:"labels"` +} + +// ObservabilityLogalertgroupRuleInput is an input type that accepts ObservabilityLogalertgroupRuleArgs and ObservabilityLogalertgroupRuleOutput values. +// You can construct a concrete instance of `ObservabilityLogalertgroupRuleInput` via: +// +// ObservabilityLogalertgroupRuleArgs{...} +type ObservabilityLogalertgroupRuleInput interface { + pulumi.Input + + ToObservabilityLogalertgroupRuleOutput() ObservabilityLogalertgroupRuleOutput + ToObservabilityLogalertgroupRuleOutputWithContext(context.Context) ObservabilityLogalertgroupRuleOutput +} + +type ObservabilityLogalertgroupRuleArgs struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert pulumi.StringInput `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression pulumi.StringInput `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For pulumi.StringPtrInput `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (ObservabilityLogalertgroupRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (i ObservabilityLogalertgroupRuleArgs) ToObservabilityLogalertgroupRuleOutput() ObservabilityLogalertgroupRuleOutput { + return i.ToObservabilityLogalertgroupRuleOutputWithContext(context.Background()) +} + +func (i ObservabilityLogalertgroupRuleArgs) ToObservabilityLogalertgroupRuleOutputWithContext(ctx context.Context) ObservabilityLogalertgroupRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityLogalertgroupRuleOutput) +} + +// ObservabilityLogalertgroupRuleArrayInput is an input type that accepts ObservabilityLogalertgroupRuleArray and ObservabilityLogalertgroupRuleArrayOutput values. +// You can construct a concrete instance of `ObservabilityLogalertgroupRuleArrayInput` via: +// +// ObservabilityLogalertgroupRuleArray{ ObservabilityLogalertgroupRuleArgs{...} } +type ObservabilityLogalertgroupRuleArrayInput interface { + pulumi.Input + + ToObservabilityLogalertgroupRuleArrayOutput() ObservabilityLogalertgroupRuleArrayOutput + ToObservabilityLogalertgroupRuleArrayOutputWithContext(context.Context) ObservabilityLogalertgroupRuleArrayOutput +} + +type ObservabilityLogalertgroupRuleArray []ObservabilityLogalertgroupRuleInput + +func (ObservabilityLogalertgroupRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (i ObservabilityLogalertgroupRuleArray) ToObservabilityLogalertgroupRuleArrayOutput() ObservabilityLogalertgroupRuleArrayOutput { + return i.ToObservabilityLogalertgroupRuleArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityLogalertgroupRuleArray) ToObservabilityLogalertgroupRuleArrayOutputWithContext(ctx context.Context) ObservabilityLogalertgroupRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityLogalertgroupRuleArrayOutput) +} + +type ObservabilityLogalertgroupRuleOutput struct{ *pulumi.OutputState } + +func (ObservabilityLogalertgroupRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (o ObservabilityLogalertgroupRuleOutput) ToObservabilityLogalertgroupRuleOutput() ObservabilityLogalertgroupRuleOutput { + return o +} + +func (o ObservabilityLogalertgroupRuleOutput) ToObservabilityLogalertgroupRuleOutputWithContext(ctx context.Context) ObservabilityLogalertgroupRuleOutput { + return o +} + +// The name of the alert rule. Is the identifier and must be unique in the group. +func (o ObservabilityLogalertgroupRuleOutput) Alert() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityLogalertgroupRule) string { return v.Alert }).(pulumi.StringOutput) +} + +// A map of key:value. Annotations to add or overwrite for each alert +func (o ObservabilityLogalertgroupRuleOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityLogalertgroupRule) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. +func (o ObservabilityLogalertgroupRuleOutput) Expression() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityLogalertgroupRule) string { return v.Expression }).(pulumi.StringOutput) +} + +// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s +func (o ObservabilityLogalertgroupRuleOutput) For() pulumi.StringPtrOutput { + return o.ApplyT(func(v ObservabilityLogalertgroupRule) *string { return v.For }).(pulumi.StringPtrOutput) +} + +// A map of key:value. Labels to add or overwrite for each alert +func (o ObservabilityLogalertgroupRuleOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityLogalertgroupRule) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type ObservabilityLogalertgroupRuleArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityLogalertgroupRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (o ObservabilityLogalertgroupRuleArrayOutput) ToObservabilityLogalertgroupRuleArrayOutput() ObservabilityLogalertgroupRuleArrayOutput { + return o +} + +func (o ObservabilityLogalertgroupRuleArrayOutput) ToObservabilityLogalertgroupRuleArrayOutputWithContext(ctx context.Context) ObservabilityLogalertgroupRuleArrayOutput { + return o +} + +func (o ObservabilityLogalertgroupRuleArrayOutput) Index(i pulumi.IntInput) ObservabilityLogalertgroupRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityLogalertgroupRule { + return vs[0].([]ObservabilityLogalertgroupRule)[vs[1].(int)] + }).(ObservabilityLogalertgroupRuleOutput) +} + +type ObservabilityScrapeconfigBasicAuth struct { + // Specifies basic auth password. + Password string `pulumi:"password"` + // Specifies basic auth username. + Username string `pulumi:"username"` +} + +// ObservabilityScrapeconfigBasicAuthInput is an input type that accepts ObservabilityScrapeconfigBasicAuthArgs and ObservabilityScrapeconfigBasicAuthOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigBasicAuthInput` via: +// +// ObservabilityScrapeconfigBasicAuthArgs{...} +type ObservabilityScrapeconfigBasicAuthInput interface { + pulumi.Input + + ToObservabilityScrapeconfigBasicAuthOutput() ObservabilityScrapeconfigBasicAuthOutput + ToObservabilityScrapeconfigBasicAuthOutputWithContext(context.Context) ObservabilityScrapeconfigBasicAuthOutput +} + +type ObservabilityScrapeconfigBasicAuthArgs struct { + // Specifies basic auth password. + Password pulumi.StringInput `pulumi:"password"` + // Specifies basic auth username. + Username pulumi.StringInput `pulumi:"username"` +} + +func (ObservabilityScrapeconfigBasicAuthArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigBasicAuthArgs) ToObservabilityScrapeconfigBasicAuthOutput() ObservabilityScrapeconfigBasicAuthOutput { + return i.ToObservabilityScrapeconfigBasicAuthOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigBasicAuthArgs) ToObservabilityScrapeconfigBasicAuthOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigBasicAuthOutput) +} + +func (i ObservabilityScrapeconfigBasicAuthArgs) ToObservabilityScrapeconfigBasicAuthPtrOutput() ObservabilityScrapeconfigBasicAuthPtrOutput { + return i.ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigBasicAuthArgs) ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigBasicAuthOutput).ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(ctx) +} + +// ObservabilityScrapeconfigBasicAuthPtrInput is an input type that accepts ObservabilityScrapeconfigBasicAuthArgs, ObservabilityScrapeconfigBasicAuthPtr and ObservabilityScrapeconfigBasicAuthPtrOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigBasicAuthPtrInput` via: +// +// ObservabilityScrapeconfigBasicAuthArgs{...} +// +// or: +// +// nil +type ObservabilityScrapeconfigBasicAuthPtrInput interface { + pulumi.Input + + ToObservabilityScrapeconfigBasicAuthPtrOutput() ObservabilityScrapeconfigBasicAuthPtrOutput + ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(context.Context) ObservabilityScrapeconfigBasicAuthPtrOutput +} + +type observabilityScrapeconfigBasicAuthPtrType ObservabilityScrapeconfigBasicAuthArgs + +func ObservabilityScrapeconfigBasicAuthPtr(v *ObservabilityScrapeconfigBasicAuthArgs) ObservabilityScrapeconfigBasicAuthPtrInput { + return (*observabilityScrapeconfigBasicAuthPtrType)(v) +} + +func (*observabilityScrapeconfigBasicAuthPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (i *observabilityScrapeconfigBasicAuthPtrType) ToObservabilityScrapeconfigBasicAuthPtrOutput() ObservabilityScrapeconfigBasicAuthPtrOutput { + return i.ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(context.Background()) +} + +func (i *observabilityScrapeconfigBasicAuthPtrType) ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigBasicAuthPtrOutput) +} + +type ObservabilityScrapeconfigBasicAuthOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigBasicAuthOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigBasicAuthOutput) ToObservabilityScrapeconfigBasicAuthOutput() ObservabilityScrapeconfigBasicAuthOutput { + return o +} + +func (o ObservabilityScrapeconfigBasicAuthOutput) ToObservabilityScrapeconfigBasicAuthOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthOutput { + return o +} + +func (o ObservabilityScrapeconfigBasicAuthOutput) ToObservabilityScrapeconfigBasicAuthPtrOutput() ObservabilityScrapeconfigBasicAuthPtrOutput { + return o.ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(context.Background()) +} + +func (o ObservabilityScrapeconfigBasicAuthOutput) ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityScrapeconfigBasicAuth) *ObservabilityScrapeconfigBasicAuth { + return &v + }).(ObservabilityScrapeconfigBasicAuthPtrOutput) +} + +// Specifies basic auth password. +func (o ObservabilityScrapeconfigBasicAuthOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityScrapeconfigBasicAuth) string { return v.Password }).(pulumi.StringOutput) +} + +// Specifies basic auth username. +func (o ObservabilityScrapeconfigBasicAuthOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v ObservabilityScrapeconfigBasicAuth) string { return v.Username }).(pulumi.StringOutput) +} + +type ObservabilityScrapeconfigBasicAuthPtrOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigBasicAuthPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigBasicAuthPtrOutput) ToObservabilityScrapeconfigBasicAuthPtrOutput() ObservabilityScrapeconfigBasicAuthPtrOutput { + return o +} + +func (o ObservabilityScrapeconfigBasicAuthPtrOutput) ToObservabilityScrapeconfigBasicAuthPtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigBasicAuthPtrOutput { + return o +} + +func (o ObservabilityScrapeconfigBasicAuthPtrOutput) Elem() ObservabilityScrapeconfigBasicAuthOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfigBasicAuth) ObservabilityScrapeconfigBasicAuth { + if v != nil { + return *v + } + var ret ObservabilityScrapeconfigBasicAuth + return ret + }).(ObservabilityScrapeconfigBasicAuthOutput) +} + +// Specifies basic auth password. +func (o ObservabilityScrapeconfigBasicAuthPtrOutput) Password() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfigBasicAuth) *string { + if v == nil { + return nil + } + return &v.Password + }).(pulumi.StringPtrOutput) +} + +// Specifies basic auth username. +func (o ObservabilityScrapeconfigBasicAuthPtrOutput) Username() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfigBasicAuth) *string { + if v == nil { + return nil + } + return &v.Username + }).(pulumi.StringPtrOutput) +} + +type ObservabilityScrapeconfigSaml2 struct { + // Specifies if URL parameters are enabled. Defaults to `true` + EnableUrlParameters *bool `pulumi:"enableUrlParameters"` +} + +// ObservabilityScrapeconfigSaml2Input is an input type that accepts ObservabilityScrapeconfigSaml2Args and ObservabilityScrapeconfigSaml2Output values. +// You can construct a concrete instance of `ObservabilityScrapeconfigSaml2Input` via: +// +// ObservabilityScrapeconfigSaml2Args{...} +type ObservabilityScrapeconfigSaml2Input interface { + pulumi.Input + + ToObservabilityScrapeconfigSaml2Output() ObservabilityScrapeconfigSaml2Output + ToObservabilityScrapeconfigSaml2OutputWithContext(context.Context) ObservabilityScrapeconfigSaml2Output +} + +type ObservabilityScrapeconfigSaml2Args struct { + // Specifies if URL parameters are enabled. Defaults to `true` + EnableUrlParameters pulumi.BoolPtrInput `pulumi:"enableUrlParameters"` +} + +func (ObservabilityScrapeconfigSaml2Args) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigSaml2Args) ToObservabilityScrapeconfigSaml2Output() ObservabilityScrapeconfigSaml2Output { + return i.ToObservabilityScrapeconfigSaml2OutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigSaml2Args) ToObservabilityScrapeconfigSaml2OutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2Output { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigSaml2Output) +} + +func (i ObservabilityScrapeconfigSaml2Args) ToObservabilityScrapeconfigSaml2PtrOutput() ObservabilityScrapeconfigSaml2PtrOutput { + return i.ToObservabilityScrapeconfigSaml2PtrOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigSaml2Args) ToObservabilityScrapeconfigSaml2PtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2PtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigSaml2Output).ToObservabilityScrapeconfigSaml2PtrOutputWithContext(ctx) +} + +// ObservabilityScrapeconfigSaml2PtrInput is an input type that accepts ObservabilityScrapeconfigSaml2Args, ObservabilityScrapeconfigSaml2Ptr and ObservabilityScrapeconfigSaml2PtrOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigSaml2PtrInput` via: +// +// ObservabilityScrapeconfigSaml2Args{...} +// +// or: +// +// nil +type ObservabilityScrapeconfigSaml2PtrInput interface { + pulumi.Input + + ToObservabilityScrapeconfigSaml2PtrOutput() ObservabilityScrapeconfigSaml2PtrOutput + ToObservabilityScrapeconfigSaml2PtrOutputWithContext(context.Context) ObservabilityScrapeconfigSaml2PtrOutput +} + +type observabilityScrapeconfigSaml2PtrType ObservabilityScrapeconfigSaml2Args + +func ObservabilityScrapeconfigSaml2Ptr(v *ObservabilityScrapeconfigSaml2Args) ObservabilityScrapeconfigSaml2PtrInput { + return (*observabilityScrapeconfigSaml2PtrType)(v) +} + +func (*observabilityScrapeconfigSaml2PtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (i *observabilityScrapeconfigSaml2PtrType) ToObservabilityScrapeconfigSaml2PtrOutput() ObservabilityScrapeconfigSaml2PtrOutput { + return i.ToObservabilityScrapeconfigSaml2PtrOutputWithContext(context.Background()) +} + +func (i *observabilityScrapeconfigSaml2PtrType) ToObservabilityScrapeconfigSaml2PtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2PtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigSaml2PtrOutput) +} + +type ObservabilityScrapeconfigSaml2Output struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigSaml2Output) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigSaml2Output) ToObservabilityScrapeconfigSaml2Output() ObservabilityScrapeconfigSaml2Output { + return o +} + +func (o ObservabilityScrapeconfigSaml2Output) ToObservabilityScrapeconfigSaml2OutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2Output { + return o +} + +func (o ObservabilityScrapeconfigSaml2Output) ToObservabilityScrapeconfigSaml2PtrOutput() ObservabilityScrapeconfigSaml2PtrOutput { + return o.ToObservabilityScrapeconfigSaml2PtrOutputWithContext(context.Background()) +} + +func (o ObservabilityScrapeconfigSaml2Output) ToObservabilityScrapeconfigSaml2PtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2PtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityScrapeconfigSaml2) *ObservabilityScrapeconfigSaml2 { + return &v + }).(ObservabilityScrapeconfigSaml2PtrOutput) +} + +// Specifies if URL parameters are enabled. Defaults to `true` +func (o ObservabilityScrapeconfigSaml2Output) EnableUrlParameters() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ObservabilityScrapeconfigSaml2) *bool { return v.EnableUrlParameters }).(pulumi.BoolPtrOutput) +} + +type ObservabilityScrapeconfigSaml2PtrOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigSaml2PtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigSaml2PtrOutput) ToObservabilityScrapeconfigSaml2PtrOutput() ObservabilityScrapeconfigSaml2PtrOutput { + return o +} + +func (o ObservabilityScrapeconfigSaml2PtrOutput) ToObservabilityScrapeconfigSaml2PtrOutputWithContext(ctx context.Context) ObservabilityScrapeconfigSaml2PtrOutput { + return o +} + +func (o ObservabilityScrapeconfigSaml2PtrOutput) Elem() ObservabilityScrapeconfigSaml2Output { + return o.ApplyT(func(v *ObservabilityScrapeconfigSaml2) ObservabilityScrapeconfigSaml2 { + if v != nil { + return *v + } + var ret ObservabilityScrapeconfigSaml2 + return ret + }).(ObservabilityScrapeconfigSaml2Output) +} + +// Specifies if URL parameters are enabled. Defaults to `true` +func (o ObservabilityScrapeconfigSaml2PtrOutput) EnableUrlParameters() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ObservabilityScrapeconfigSaml2) *bool { + if v == nil { + return nil + } + return v.EnableUrlParameters + }).(pulumi.BoolPtrOutput) +} + +type ObservabilityScrapeconfigTarget struct { + // Specifies labels. + Labels map[string]string `pulumi:"labels"` + // Specifies target URLs. + Urls []string `pulumi:"urls"` +} + +// ObservabilityScrapeconfigTargetInput is an input type that accepts ObservabilityScrapeconfigTargetArgs and ObservabilityScrapeconfigTargetOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigTargetInput` via: +// +// ObservabilityScrapeconfigTargetArgs{...} +type ObservabilityScrapeconfigTargetInput interface { + pulumi.Input + + ToObservabilityScrapeconfigTargetOutput() ObservabilityScrapeconfigTargetOutput + ToObservabilityScrapeconfigTargetOutputWithContext(context.Context) ObservabilityScrapeconfigTargetOutput +} + +type ObservabilityScrapeconfigTargetArgs struct { + // Specifies labels. + Labels pulumi.StringMapInput `pulumi:"labels"` + // Specifies target URLs. + Urls pulumi.StringArrayInput `pulumi:"urls"` +} + +func (ObservabilityScrapeconfigTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigTargetArgs) ToObservabilityScrapeconfigTargetOutput() ObservabilityScrapeconfigTargetOutput { + return i.ToObservabilityScrapeconfigTargetOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigTargetArgs) ToObservabilityScrapeconfigTargetOutputWithContext(ctx context.Context) ObservabilityScrapeconfigTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigTargetOutput) +} + +// ObservabilityScrapeconfigTargetArrayInput is an input type that accepts ObservabilityScrapeconfigTargetArray and ObservabilityScrapeconfigTargetArrayOutput values. +// You can construct a concrete instance of `ObservabilityScrapeconfigTargetArrayInput` via: +// +// ObservabilityScrapeconfigTargetArray{ ObservabilityScrapeconfigTargetArgs{...} } +type ObservabilityScrapeconfigTargetArrayInput interface { + pulumi.Input + + ToObservabilityScrapeconfigTargetArrayOutput() ObservabilityScrapeconfigTargetArrayOutput + ToObservabilityScrapeconfigTargetArrayOutputWithContext(context.Context) ObservabilityScrapeconfigTargetArrayOutput +} + +type ObservabilityScrapeconfigTargetArray []ObservabilityScrapeconfigTargetInput + +func (ObservabilityScrapeconfigTargetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (i ObservabilityScrapeconfigTargetArray) ToObservabilityScrapeconfigTargetArrayOutput() ObservabilityScrapeconfigTargetArrayOutput { + return i.ToObservabilityScrapeconfigTargetArrayOutputWithContext(context.Background()) +} + +func (i ObservabilityScrapeconfigTargetArray) ToObservabilityScrapeconfigTargetArrayOutputWithContext(ctx context.Context) ObservabilityScrapeconfigTargetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ObservabilityScrapeconfigTargetArrayOutput) +} + +type ObservabilityScrapeconfigTargetOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigTargetOutput) ToObservabilityScrapeconfigTargetOutput() ObservabilityScrapeconfigTargetOutput { + return o +} + +func (o ObservabilityScrapeconfigTargetOutput) ToObservabilityScrapeconfigTargetOutputWithContext(ctx context.Context) ObservabilityScrapeconfigTargetOutput { + return o +} + +// Specifies labels. +func (o ObservabilityScrapeconfigTargetOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v ObservabilityScrapeconfigTarget) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// Specifies target URLs. +func (o ObservabilityScrapeconfigTargetOutput) Urls() pulumi.StringArrayOutput { + return o.ApplyT(func(v ObservabilityScrapeconfigTarget) []string { return v.Urls }).(pulumi.StringArrayOutput) +} + +type ObservabilityScrapeconfigTargetArrayOutput struct{ *pulumi.OutputState } + +func (ObservabilityScrapeconfigTargetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (o ObservabilityScrapeconfigTargetArrayOutput) ToObservabilityScrapeconfigTargetArrayOutput() ObservabilityScrapeconfigTargetArrayOutput { + return o +} + +func (o ObservabilityScrapeconfigTargetArrayOutput) ToObservabilityScrapeconfigTargetArrayOutputWithContext(ctx context.Context) ObservabilityScrapeconfigTargetArrayOutput { + return o +} + +func (o ObservabilityScrapeconfigTargetArrayOutput) Index(i pulumi.IntInput) ObservabilityScrapeconfigTargetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ObservabilityScrapeconfigTarget { + return vs[0].([]ObservabilityScrapeconfigTarget)[vs[1].(int)] + }).(ObservabilityScrapeconfigTargetOutput) +} + +type OpensearchInstanceParameters struct { + // Enable monitoring. + EnableMonitoring *bool `pulumi:"enableMonitoring"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite *string `pulumi:"graphite"` + // The garbage collector to use for OpenSearch. + JavaGarbageCollector *string `pulumi:"javaGarbageCollector"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace *int `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace *int `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold *int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency *int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix *string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId *string `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + Plugins []string `pulumi:"plugins"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl *string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // The TLS protocol to use. + TlsProtocols *string `pulumi:"tlsProtocols"` +} + +// OpensearchInstanceParametersInput is an input type that accepts OpensearchInstanceParametersArgs and OpensearchInstanceParametersOutput values. +// You can construct a concrete instance of `OpensearchInstanceParametersInput` via: +// +// OpensearchInstanceParametersArgs{...} +type OpensearchInstanceParametersInput interface { + pulumi.Input + + ToOpensearchInstanceParametersOutput() OpensearchInstanceParametersOutput + ToOpensearchInstanceParametersOutputWithContext(context.Context) OpensearchInstanceParametersOutput +} + +type OpensearchInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolPtrInput `pulumi:"enableMonitoring"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite pulumi.StringPtrInput `pulumi:"graphite"` + // The garbage collector to use for OpenSearch. + JavaGarbageCollector pulumi.StringPtrInput `pulumi:"javaGarbageCollector"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace pulumi.IntPtrInput `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace pulumi.IntPtrInput `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntPtrInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency pulumi.IntPtrInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix pulumi.StringPtrInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringPtrInput `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + Plugins pulumi.StringArrayInput `pulumi:"plugins"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringPtrInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // The TLS protocol to use. + TlsProtocols pulumi.StringPtrInput `pulumi:"tlsProtocols"` +} + +func (OpensearchInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OpensearchInstanceParameters)(nil)).Elem() +} + +func (i OpensearchInstanceParametersArgs) ToOpensearchInstanceParametersOutput() OpensearchInstanceParametersOutput { + return i.ToOpensearchInstanceParametersOutputWithContext(context.Background()) +} + +func (i OpensearchInstanceParametersArgs) ToOpensearchInstanceParametersOutputWithContext(ctx context.Context) OpensearchInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceParametersOutput) +} + +func (i OpensearchInstanceParametersArgs) ToOpensearchInstanceParametersPtrOutput() OpensearchInstanceParametersPtrOutput { + return i.ToOpensearchInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i OpensearchInstanceParametersArgs) ToOpensearchInstanceParametersPtrOutputWithContext(ctx context.Context) OpensearchInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceParametersOutput).ToOpensearchInstanceParametersPtrOutputWithContext(ctx) +} + +// OpensearchInstanceParametersPtrInput is an input type that accepts OpensearchInstanceParametersArgs, OpensearchInstanceParametersPtr and OpensearchInstanceParametersPtrOutput values. +// You can construct a concrete instance of `OpensearchInstanceParametersPtrInput` via: +// +// OpensearchInstanceParametersArgs{...} +// +// or: +// +// nil +type OpensearchInstanceParametersPtrInput interface { + pulumi.Input + + ToOpensearchInstanceParametersPtrOutput() OpensearchInstanceParametersPtrOutput + ToOpensearchInstanceParametersPtrOutputWithContext(context.Context) OpensearchInstanceParametersPtrOutput +} + +type opensearchInstanceParametersPtrType OpensearchInstanceParametersArgs + +func OpensearchInstanceParametersPtr(v *OpensearchInstanceParametersArgs) OpensearchInstanceParametersPtrInput { + return (*opensearchInstanceParametersPtrType)(v) +} + +func (*opensearchInstanceParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchInstanceParameters)(nil)).Elem() +} + +func (i *opensearchInstanceParametersPtrType) ToOpensearchInstanceParametersPtrOutput() OpensearchInstanceParametersPtrOutput { + return i.ToOpensearchInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i *opensearchInstanceParametersPtrType) ToOpensearchInstanceParametersPtrOutputWithContext(ctx context.Context) OpensearchInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OpensearchInstanceParametersPtrOutput) +} + +type OpensearchInstanceParametersOutput struct{ *pulumi.OutputState } + +func (OpensearchInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OpensearchInstanceParameters)(nil)).Elem() +} + +func (o OpensearchInstanceParametersOutput) ToOpensearchInstanceParametersOutput() OpensearchInstanceParametersOutput { + return o +} + +func (o OpensearchInstanceParametersOutput) ToOpensearchInstanceParametersOutputWithContext(ctx context.Context) OpensearchInstanceParametersOutput { + return o +} + +func (o OpensearchInstanceParametersOutput) ToOpensearchInstanceParametersPtrOutput() OpensearchInstanceParametersPtrOutput { + return o.ToOpensearchInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (o OpensearchInstanceParametersOutput) ToOpensearchInstanceParametersPtrOutputWithContext(ctx context.Context) OpensearchInstanceParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OpensearchInstanceParameters) *OpensearchInstanceParameters { + return &v + }).(OpensearchInstanceParametersPtrOutput) +} + +// Enable monitoring. +func (o OpensearchInstanceParametersOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *bool { return v.EnableMonitoring }).(pulumi.BoolPtrOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o OpensearchInstanceParametersOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.Graphite }).(pulumi.StringPtrOutput) +} + +// The garbage collector to use for OpenSearch. +func (o OpensearchInstanceParametersOutput) JavaGarbageCollector() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.JavaGarbageCollector }).(pulumi.StringPtrOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o OpensearchInstanceParametersOutput) JavaHeapspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *int { return v.JavaHeapspace }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o OpensearchInstanceParametersOutput) JavaMaxmetaspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *int { return v.JavaMaxmetaspace }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o OpensearchInstanceParametersOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *int { return v.MaxDiskThreshold }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o OpensearchInstanceParametersOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *int { return v.MetricsFrequency }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o OpensearchInstanceParametersOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.MetricsPrefix }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o OpensearchInstanceParametersOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.MonitoringInstanceId }).(pulumi.StringPtrOutput) +} + +// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. +func (o OpensearchInstanceParametersOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) []string { return v.Plugins }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o OpensearchInstanceParametersOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.SgwAcl }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o OpensearchInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o OpensearchInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// The TLS protocol to use. +func (o OpensearchInstanceParametersOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v OpensearchInstanceParameters) *string { return v.TlsProtocols }).(pulumi.StringPtrOutput) +} + +type OpensearchInstanceParametersPtrOutput struct{ *pulumi.OutputState } + +func (OpensearchInstanceParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OpensearchInstanceParameters)(nil)).Elem() +} + +func (o OpensearchInstanceParametersPtrOutput) ToOpensearchInstanceParametersPtrOutput() OpensearchInstanceParametersPtrOutput { + return o +} + +func (o OpensearchInstanceParametersPtrOutput) ToOpensearchInstanceParametersPtrOutputWithContext(ctx context.Context) OpensearchInstanceParametersPtrOutput { + return o +} + +func (o OpensearchInstanceParametersPtrOutput) Elem() OpensearchInstanceParametersOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) OpensearchInstanceParameters { + if v != nil { + return *v + } + var ret OpensearchInstanceParameters + return ret + }).(OpensearchInstanceParametersOutput) +} + +// Enable monitoring. +func (o OpensearchInstanceParametersPtrOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *bool { + if v == nil { + return nil + } + return v.EnableMonitoring + }).(pulumi.BoolPtrOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o OpensearchInstanceParametersPtrOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.Graphite + }).(pulumi.StringPtrOutput) +} + +// The garbage collector to use for OpenSearch. +func (o OpensearchInstanceParametersPtrOutput) JavaGarbageCollector() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.JavaGarbageCollector + }).(pulumi.StringPtrOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o OpensearchInstanceParametersPtrOutput) JavaHeapspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *int { + if v == nil { + return nil + } + return v.JavaHeapspace + }).(pulumi.IntPtrOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o OpensearchInstanceParametersPtrOutput) JavaMaxmetaspace() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *int { + if v == nil { + return nil + } + return v.JavaMaxmetaspace + }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o OpensearchInstanceParametersPtrOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxDiskThreshold + }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o OpensearchInstanceParametersPtrOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *int { + if v == nil { + return nil + } + return v.MetricsFrequency + }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o OpensearchInstanceParametersPtrOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.MetricsPrefix + }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o OpensearchInstanceParametersPtrOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.MonitoringInstanceId + }).(pulumi.StringPtrOutput) +} + +// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. +func (o OpensearchInstanceParametersPtrOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) []string { + if v == nil { + return nil + } + return v.Plugins + }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o OpensearchInstanceParametersPtrOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.SgwAcl + }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o OpensearchInstanceParametersPtrOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) []string { + if v == nil { + return nil + } + return v.Syslogs + }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o OpensearchInstanceParametersPtrOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) []string { + if v == nil { + return nil + } + return v.TlsCiphers + }).(pulumi.StringArrayOutput) +} + +// The TLS protocol to use. +func (o OpensearchInstanceParametersPtrOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OpensearchInstanceParameters) *string { + if v == nil { + return nil + } + return v.TlsProtocols + }).(pulumi.StringPtrOutput) +} + +type PostgresflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description *string `pulumi:"description"` + Id *string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// PostgresflexInstanceFlavorInput is an input type that accepts PostgresflexInstanceFlavorArgs and PostgresflexInstanceFlavorOutput values. +// You can construct a concrete instance of `PostgresflexInstanceFlavorInput` via: +// +// PostgresflexInstanceFlavorArgs{...} +type PostgresflexInstanceFlavorInput interface { + pulumi.Input + + ToPostgresflexInstanceFlavorOutput() PostgresflexInstanceFlavorOutput + ToPostgresflexInstanceFlavorOutputWithContext(context.Context) PostgresflexInstanceFlavorOutput +} + +type PostgresflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringPtrInput `pulumi:"description"` + Id pulumi.StringPtrInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (PostgresflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*PostgresflexInstanceFlavor)(nil)).Elem() +} + +func (i PostgresflexInstanceFlavorArgs) ToPostgresflexInstanceFlavorOutput() PostgresflexInstanceFlavorOutput { + return i.ToPostgresflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceFlavorArgs) ToPostgresflexInstanceFlavorOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceFlavorOutput) +} + +func (i PostgresflexInstanceFlavorArgs) ToPostgresflexInstanceFlavorPtrOutput() PostgresflexInstanceFlavorPtrOutput { + return i.ToPostgresflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceFlavorArgs) ToPostgresflexInstanceFlavorPtrOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceFlavorOutput).ToPostgresflexInstanceFlavorPtrOutputWithContext(ctx) +} + +// PostgresflexInstanceFlavorPtrInput is an input type that accepts PostgresflexInstanceFlavorArgs, PostgresflexInstanceFlavorPtr and PostgresflexInstanceFlavorPtrOutput values. +// You can construct a concrete instance of `PostgresflexInstanceFlavorPtrInput` via: +// +// PostgresflexInstanceFlavorArgs{...} +// +// or: +// +// nil +type PostgresflexInstanceFlavorPtrInput interface { + pulumi.Input + + ToPostgresflexInstanceFlavorPtrOutput() PostgresflexInstanceFlavorPtrOutput + ToPostgresflexInstanceFlavorPtrOutputWithContext(context.Context) PostgresflexInstanceFlavorPtrOutput +} + +type postgresflexInstanceFlavorPtrType PostgresflexInstanceFlavorArgs + +func PostgresflexInstanceFlavorPtr(v *PostgresflexInstanceFlavorArgs) PostgresflexInstanceFlavorPtrInput { + return (*postgresflexInstanceFlavorPtrType)(v) +} + +func (*postgresflexInstanceFlavorPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstanceFlavor)(nil)).Elem() +} + +func (i *postgresflexInstanceFlavorPtrType) ToPostgresflexInstanceFlavorPtrOutput() PostgresflexInstanceFlavorPtrOutput { + return i.ToPostgresflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i *postgresflexInstanceFlavorPtrType) ToPostgresflexInstanceFlavorPtrOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceFlavorPtrOutput) +} + +type PostgresflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*PostgresflexInstanceFlavor)(nil)).Elem() +} + +func (o PostgresflexInstanceFlavorOutput) ToPostgresflexInstanceFlavorOutput() PostgresflexInstanceFlavorOutput { + return o +} + +func (o PostgresflexInstanceFlavorOutput) ToPostgresflexInstanceFlavorOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorOutput { + return o +} + +func (o PostgresflexInstanceFlavorOutput) ToPostgresflexInstanceFlavorPtrOutput() PostgresflexInstanceFlavorPtrOutput { + return o.ToPostgresflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (o PostgresflexInstanceFlavorOutput) ToPostgresflexInstanceFlavorPtrOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v PostgresflexInstanceFlavor) *PostgresflexInstanceFlavor { + return &v + }).(PostgresflexInstanceFlavorPtrOutput) +} + +func (o PostgresflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v PostgresflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o PostgresflexInstanceFlavorOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v PostgresflexInstanceFlavor) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o PostgresflexInstanceFlavorOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v PostgresflexInstanceFlavor) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +func (o PostgresflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v PostgresflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type PostgresflexInstanceFlavorPtrOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceFlavorPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstanceFlavor)(nil)).Elem() +} + +func (o PostgresflexInstanceFlavorPtrOutput) ToPostgresflexInstanceFlavorPtrOutput() PostgresflexInstanceFlavorPtrOutput { + return o +} + +func (o PostgresflexInstanceFlavorPtrOutput) ToPostgresflexInstanceFlavorPtrOutputWithContext(ctx context.Context) PostgresflexInstanceFlavorPtrOutput { + return o +} + +func (o PostgresflexInstanceFlavorPtrOutput) Elem() PostgresflexInstanceFlavorOutput { + return o.ApplyT(func(v *PostgresflexInstanceFlavor) PostgresflexInstanceFlavor { + if v != nil { + return *v + } + var ret PostgresflexInstanceFlavor + return ret + }).(PostgresflexInstanceFlavorOutput) +} + +func (o PostgresflexInstanceFlavorPtrOutput) Cpu() pulumi.IntPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Cpu + }).(pulumi.IntPtrOutput) +} + +func (o PostgresflexInstanceFlavorPtrOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Description + }).(pulumi.StringPtrOutput) +} + +func (o PostgresflexInstanceFlavorPtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Id + }).(pulumi.StringPtrOutput) +} + +func (o PostgresflexInstanceFlavorPtrOutput) Ram() pulumi.IntPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Ram + }).(pulumi.IntPtrOutput) +} + +type PostgresflexInstanceStorage struct { + Class string `pulumi:"class"` + Size int `pulumi:"size"` +} + +// PostgresflexInstanceStorageInput is an input type that accepts PostgresflexInstanceStorageArgs and PostgresflexInstanceStorageOutput values. +// You can construct a concrete instance of `PostgresflexInstanceStorageInput` via: +// +// PostgresflexInstanceStorageArgs{...} +type PostgresflexInstanceStorageInput interface { + pulumi.Input + + ToPostgresflexInstanceStorageOutput() PostgresflexInstanceStorageOutput + ToPostgresflexInstanceStorageOutputWithContext(context.Context) PostgresflexInstanceStorageOutput +} + +type PostgresflexInstanceStorageArgs struct { + Class pulumi.StringInput `pulumi:"class"` + Size pulumi.IntInput `pulumi:"size"` +} + +func (PostgresflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*PostgresflexInstanceStorage)(nil)).Elem() +} + +func (i PostgresflexInstanceStorageArgs) ToPostgresflexInstanceStorageOutput() PostgresflexInstanceStorageOutput { + return i.ToPostgresflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceStorageArgs) ToPostgresflexInstanceStorageOutputWithContext(ctx context.Context) PostgresflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceStorageOutput) +} + +func (i PostgresflexInstanceStorageArgs) ToPostgresflexInstanceStoragePtrOutput() PostgresflexInstanceStoragePtrOutput { + return i.ToPostgresflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i PostgresflexInstanceStorageArgs) ToPostgresflexInstanceStoragePtrOutputWithContext(ctx context.Context) PostgresflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceStorageOutput).ToPostgresflexInstanceStoragePtrOutputWithContext(ctx) +} + +// PostgresflexInstanceStoragePtrInput is an input type that accepts PostgresflexInstanceStorageArgs, PostgresflexInstanceStoragePtr and PostgresflexInstanceStoragePtrOutput values. +// You can construct a concrete instance of `PostgresflexInstanceStoragePtrInput` via: +// +// PostgresflexInstanceStorageArgs{...} +// +// or: +// +// nil +type PostgresflexInstanceStoragePtrInput interface { + pulumi.Input + + ToPostgresflexInstanceStoragePtrOutput() PostgresflexInstanceStoragePtrOutput + ToPostgresflexInstanceStoragePtrOutputWithContext(context.Context) PostgresflexInstanceStoragePtrOutput +} + +type postgresflexInstanceStoragePtrType PostgresflexInstanceStorageArgs + +func PostgresflexInstanceStoragePtr(v *PostgresflexInstanceStorageArgs) PostgresflexInstanceStoragePtrInput { + return (*postgresflexInstanceStoragePtrType)(v) +} + +func (*postgresflexInstanceStoragePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstanceStorage)(nil)).Elem() +} + +func (i *postgresflexInstanceStoragePtrType) ToPostgresflexInstanceStoragePtrOutput() PostgresflexInstanceStoragePtrOutput { + return i.ToPostgresflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i *postgresflexInstanceStoragePtrType) ToPostgresflexInstanceStoragePtrOutputWithContext(ctx context.Context) PostgresflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(PostgresflexInstanceStoragePtrOutput) +} + +type PostgresflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*PostgresflexInstanceStorage)(nil)).Elem() +} + +func (o PostgresflexInstanceStorageOutput) ToPostgresflexInstanceStorageOutput() PostgresflexInstanceStorageOutput { + return o +} + +func (o PostgresflexInstanceStorageOutput) ToPostgresflexInstanceStorageOutputWithContext(ctx context.Context) PostgresflexInstanceStorageOutput { + return o +} + +func (o PostgresflexInstanceStorageOutput) ToPostgresflexInstanceStoragePtrOutput() PostgresflexInstanceStoragePtrOutput { + return o.ToPostgresflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (o PostgresflexInstanceStorageOutput) ToPostgresflexInstanceStoragePtrOutputWithContext(ctx context.Context) PostgresflexInstanceStoragePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v PostgresflexInstanceStorage) *PostgresflexInstanceStorage { + return &v + }).(PostgresflexInstanceStoragePtrOutput) +} + +func (o PostgresflexInstanceStorageOutput) Class() pulumi.StringOutput { + return o.ApplyT(func(v PostgresflexInstanceStorage) string { return v.Class }).(pulumi.StringOutput) +} + +func (o PostgresflexInstanceStorageOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v PostgresflexInstanceStorage) int { return v.Size }).(pulumi.IntOutput) +} + +type PostgresflexInstanceStoragePtrOutput struct{ *pulumi.OutputState } + +func (PostgresflexInstanceStoragePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**PostgresflexInstanceStorage)(nil)).Elem() +} + +func (o PostgresflexInstanceStoragePtrOutput) ToPostgresflexInstanceStoragePtrOutput() PostgresflexInstanceStoragePtrOutput { + return o +} + +func (o PostgresflexInstanceStoragePtrOutput) ToPostgresflexInstanceStoragePtrOutputWithContext(ctx context.Context) PostgresflexInstanceStoragePtrOutput { + return o +} + +func (o PostgresflexInstanceStoragePtrOutput) Elem() PostgresflexInstanceStorageOutput { + return o.ApplyT(func(v *PostgresflexInstanceStorage) PostgresflexInstanceStorage { + if v != nil { + return *v + } + var ret PostgresflexInstanceStorage + return ret + }).(PostgresflexInstanceStorageOutput) +} + +func (o PostgresflexInstanceStoragePtrOutput) Class() pulumi.StringPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceStorage) *string { + if v == nil { + return nil + } + return &v.Class + }).(pulumi.StringPtrOutput) +} + +func (o PostgresflexInstanceStoragePtrOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v *PostgresflexInstanceStorage) *int { + if v == nil { + return nil + } + return &v.Size + }).(pulumi.IntPtrOutput) +} + +type RabbitmqInstanceParameters struct { + // The timeout in milliseconds for the consumer. + ConsumerTimeout *int `pulumi:"consumerTimeout"` + // Enable monitoring. + EnableMonitoring *bool `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite *string `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold *int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency *int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix *string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId *string `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. + Plugins []string `pulumi:"plugins"` + // List of roles to assign to the instance. + Roles []string `pulumi:"roles"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl *string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // TLS protocol to use. + TlsProtocols *string `pulumi:"tlsProtocols"` +} + +// RabbitmqInstanceParametersInput is an input type that accepts RabbitmqInstanceParametersArgs and RabbitmqInstanceParametersOutput values. +// You can construct a concrete instance of `RabbitmqInstanceParametersInput` via: +// +// RabbitmqInstanceParametersArgs{...} +type RabbitmqInstanceParametersInput interface { + pulumi.Input + + ToRabbitmqInstanceParametersOutput() RabbitmqInstanceParametersOutput + ToRabbitmqInstanceParametersOutputWithContext(context.Context) RabbitmqInstanceParametersOutput +} + +type RabbitmqInstanceParametersArgs struct { + // The timeout in milliseconds for the consumer. + ConsumerTimeout pulumi.IntPtrInput `pulumi:"consumerTimeout"` + // Enable monitoring. + EnableMonitoring pulumi.BoolPtrInput `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite pulumi.StringPtrInput `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntPtrInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntPtrInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringPtrInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringPtrInput `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. + Plugins pulumi.StringArrayInput `pulumi:"plugins"` + // List of roles to assign to the instance. + Roles pulumi.StringArrayInput `pulumi:"roles"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringPtrInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // TLS protocol to use. + TlsProtocols pulumi.StringPtrInput `pulumi:"tlsProtocols"` +} + +func (RabbitmqInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RabbitmqInstanceParameters)(nil)).Elem() +} + +func (i RabbitmqInstanceParametersArgs) ToRabbitmqInstanceParametersOutput() RabbitmqInstanceParametersOutput { + return i.ToRabbitmqInstanceParametersOutputWithContext(context.Background()) +} + +func (i RabbitmqInstanceParametersArgs) ToRabbitmqInstanceParametersOutputWithContext(ctx context.Context) RabbitmqInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceParametersOutput) +} + +func (i RabbitmqInstanceParametersArgs) ToRabbitmqInstanceParametersPtrOutput() RabbitmqInstanceParametersPtrOutput { + return i.ToRabbitmqInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i RabbitmqInstanceParametersArgs) ToRabbitmqInstanceParametersPtrOutputWithContext(ctx context.Context) RabbitmqInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceParametersOutput).ToRabbitmqInstanceParametersPtrOutputWithContext(ctx) +} + +// RabbitmqInstanceParametersPtrInput is an input type that accepts RabbitmqInstanceParametersArgs, RabbitmqInstanceParametersPtr and RabbitmqInstanceParametersPtrOutput values. +// You can construct a concrete instance of `RabbitmqInstanceParametersPtrInput` via: +// +// RabbitmqInstanceParametersArgs{...} +// +// or: +// +// nil +type RabbitmqInstanceParametersPtrInput interface { + pulumi.Input + + ToRabbitmqInstanceParametersPtrOutput() RabbitmqInstanceParametersPtrOutput + ToRabbitmqInstanceParametersPtrOutputWithContext(context.Context) RabbitmqInstanceParametersPtrOutput +} + +type rabbitmqInstanceParametersPtrType RabbitmqInstanceParametersArgs + +func RabbitmqInstanceParametersPtr(v *RabbitmqInstanceParametersArgs) RabbitmqInstanceParametersPtrInput { + return (*rabbitmqInstanceParametersPtrType)(v) +} + +func (*rabbitmqInstanceParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqInstanceParameters)(nil)).Elem() +} + +func (i *rabbitmqInstanceParametersPtrType) ToRabbitmqInstanceParametersPtrOutput() RabbitmqInstanceParametersPtrOutput { + return i.ToRabbitmqInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i *rabbitmqInstanceParametersPtrType) ToRabbitmqInstanceParametersPtrOutputWithContext(ctx context.Context) RabbitmqInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceParametersPtrOutput) +} + +type RabbitmqInstanceParametersOutput struct{ *pulumi.OutputState } + +func (RabbitmqInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RabbitmqInstanceParameters)(nil)).Elem() +} + +func (o RabbitmqInstanceParametersOutput) ToRabbitmqInstanceParametersOutput() RabbitmqInstanceParametersOutput { + return o +} + +func (o RabbitmqInstanceParametersOutput) ToRabbitmqInstanceParametersOutputWithContext(ctx context.Context) RabbitmqInstanceParametersOutput { + return o +} + +func (o RabbitmqInstanceParametersOutput) ToRabbitmqInstanceParametersPtrOutput() RabbitmqInstanceParametersPtrOutput { + return o.ToRabbitmqInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (o RabbitmqInstanceParametersOutput) ToRabbitmqInstanceParametersPtrOutputWithContext(ctx context.Context) RabbitmqInstanceParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RabbitmqInstanceParameters) *RabbitmqInstanceParameters { + return &v + }).(RabbitmqInstanceParametersPtrOutput) +} + +// The timeout in milliseconds for the consumer. +func (o RabbitmqInstanceParametersOutput) ConsumerTimeout() pulumi.IntPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *int { return v.ConsumerTimeout }).(pulumi.IntPtrOutput) +} + +// Enable monitoring. +func (o RabbitmqInstanceParametersOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *bool { return v.EnableMonitoring }).(pulumi.BoolPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o RabbitmqInstanceParametersOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *string { return v.Graphite }).(pulumi.StringPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o RabbitmqInstanceParametersOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *int { return v.MaxDiskThreshold }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o RabbitmqInstanceParametersOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *int { return v.MetricsFrequency }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o RabbitmqInstanceParametersOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *string { return v.MetricsPrefix }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o RabbitmqInstanceParametersOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *string { return v.MonitoringInstanceId }).(pulumi.StringPtrOutput) +} + +// List of plugins to install. Must be a supported plugin name. +func (o RabbitmqInstanceParametersOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) []string { return v.Plugins }).(pulumi.StringArrayOutput) +} + +// List of roles to assign to the instance. +func (o RabbitmqInstanceParametersOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) []string { return v.Roles }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o RabbitmqInstanceParametersOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *string { return v.SgwAcl }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o RabbitmqInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o RabbitmqInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// TLS protocol to use. +func (o RabbitmqInstanceParametersOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v RabbitmqInstanceParameters) *string { return v.TlsProtocols }).(pulumi.StringPtrOutput) +} + +type RabbitmqInstanceParametersPtrOutput struct{ *pulumi.OutputState } + +func (RabbitmqInstanceParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqInstanceParameters)(nil)).Elem() +} + +func (o RabbitmqInstanceParametersPtrOutput) ToRabbitmqInstanceParametersPtrOutput() RabbitmqInstanceParametersPtrOutput { + return o +} + +func (o RabbitmqInstanceParametersPtrOutput) ToRabbitmqInstanceParametersPtrOutputWithContext(ctx context.Context) RabbitmqInstanceParametersPtrOutput { + return o +} + +func (o RabbitmqInstanceParametersPtrOutput) Elem() RabbitmqInstanceParametersOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) RabbitmqInstanceParameters { + if v != nil { + return *v + } + var ret RabbitmqInstanceParameters + return ret + }).(RabbitmqInstanceParametersOutput) +} + +// The timeout in milliseconds for the consumer. +func (o RabbitmqInstanceParametersPtrOutput) ConsumerTimeout() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *int { + if v == nil { + return nil + } + return v.ConsumerTimeout + }).(pulumi.IntPtrOutput) +} + +// Enable monitoring. +func (o RabbitmqInstanceParametersPtrOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *bool { + if v == nil { + return nil + } + return v.EnableMonitoring + }).(pulumi.BoolPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o RabbitmqInstanceParametersPtrOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *string { + if v == nil { + return nil + } + return v.Graphite + }).(pulumi.StringPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o RabbitmqInstanceParametersPtrOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxDiskThreshold + }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o RabbitmqInstanceParametersPtrOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *int { + if v == nil { + return nil + } + return v.MetricsFrequency + }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o RabbitmqInstanceParametersPtrOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *string { + if v == nil { + return nil + } + return v.MetricsPrefix + }).(pulumi.StringPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o RabbitmqInstanceParametersPtrOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *string { + if v == nil { + return nil + } + return v.MonitoringInstanceId + }).(pulumi.StringPtrOutput) +} + +// List of plugins to install. Must be a supported plugin name. +func (o RabbitmqInstanceParametersPtrOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) []string { + if v == nil { + return nil + } + return v.Plugins + }).(pulumi.StringArrayOutput) +} + +// List of roles to assign to the instance. +func (o RabbitmqInstanceParametersPtrOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) []string { + if v == nil { + return nil + } + return v.Roles + }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o RabbitmqInstanceParametersPtrOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *string { + if v == nil { + return nil + } + return v.SgwAcl + }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o RabbitmqInstanceParametersPtrOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) []string { + if v == nil { + return nil + } + return v.Syslogs + }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o RabbitmqInstanceParametersPtrOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) []string { + if v == nil { + return nil + } + return v.TlsCiphers + }).(pulumi.StringArrayOutput) +} + +// TLS protocol to use. +func (o RabbitmqInstanceParametersPtrOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RabbitmqInstanceParameters) *string { + if v == nil { + return nil + } + return v.TlsProtocols + }).(pulumi.StringPtrOutput) +} + +type RedisInstanceParameters struct { + // The number of milliseconds after which the instance is considered down. + DownAfterMilliseconds *int `pulumi:"downAfterMilliseconds"` + // Enable monitoring. + EnableMonitoring *bool `pulumi:"enableMonitoring"` + // The failover timeout in milliseconds. + FailoverTimeout *int `pulumi:"failoverTimeout"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite *string `pulumi:"graphite"` + // The lazy eviction enablement (yes or no). + LazyfreeLazyEviction *string `pulumi:"lazyfreeLazyEviction"` + // The lazy expire enablement (yes or no). + LazyfreeLazyExpire *string `pulumi:"lazyfreeLazyExpire"` + // The Lua time limit. + LuaTimeLimit *int `pulumi:"luaTimeLimit"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold *int `pulumi:"maxDiskThreshold"` + // The maximum number of clients. + Maxclients *int `pulumi:"maxclients"` + // The policy to handle the maximum memory (volatile-lru, noeviction, etc). + MaxmemoryPolicy *string `pulumi:"maxmemoryPolicy"` + // The maximum memory samples. + MaxmemorySamples *int `pulumi:"maxmemorySamples"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency *int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix *string `pulumi:"metricsPrefix"` + // The minimum replicas maximum lag. + MinReplicasMaxLag *int `pulumi:"minReplicasMaxLag"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId *string `pulumi:"monitoringInstanceId"` + // The notify keyspace events. + NotifyKeyspaceEvents *string `pulumi:"notifyKeyspaceEvents"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl *string `pulumi:"sgwAcl"` + // The snapshot configuration. + Snapshot *string `pulumi:"snapshot"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // TLS cipher suites to use. + TlsCiphersuites *string `pulumi:"tlsCiphersuites"` + // TLS protocol to use. + TlsProtocols *string `pulumi:"tlsProtocols"` +} + +// RedisInstanceParametersInput is an input type that accepts RedisInstanceParametersArgs and RedisInstanceParametersOutput values. +// You can construct a concrete instance of `RedisInstanceParametersInput` via: +// +// RedisInstanceParametersArgs{...} +type RedisInstanceParametersInput interface { + pulumi.Input + + ToRedisInstanceParametersOutput() RedisInstanceParametersOutput + ToRedisInstanceParametersOutputWithContext(context.Context) RedisInstanceParametersOutput +} + +type RedisInstanceParametersArgs struct { + // The number of milliseconds after which the instance is considered down. + DownAfterMilliseconds pulumi.IntPtrInput `pulumi:"downAfterMilliseconds"` + // Enable monitoring. + EnableMonitoring pulumi.BoolPtrInput `pulumi:"enableMonitoring"` + // The failover timeout in milliseconds. + FailoverTimeout pulumi.IntPtrInput `pulumi:"failoverTimeout"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite pulumi.StringPtrInput `pulumi:"graphite"` + // The lazy eviction enablement (yes or no). + LazyfreeLazyEviction pulumi.StringPtrInput `pulumi:"lazyfreeLazyEviction"` + // The lazy expire enablement (yes or no). + LazyfreeLazyExpire pulumi.StringPtrInput `pulumi:"lazyfreeLazyExpire"` + // The Lua time limit. + LuaTimeLimit pulumi.IntPtrInput `pulumi:"luaTimeLimit"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntPtrInput `pulumi:"maxDiskThreshold"` + // The maximum number of clients. + Maxclients pulumi.IntPtrInput `pulumi:"maxclients"` + // The policy to handle the maximum memory (volatile-lru, noeviction, etc). + MaxmemoryPolicy pulumi.StringPtrInput `pulumi:"maxmemoryPolicy"` + // The maximum memory samples. + MaxmemorySamples pulumi.IntPtrInput `pulumi:"maxmemorySamples"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntPtrInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringPtrInput `pulumi:"metricsPrefix"` + // The minimum replicas maximum lag. + MinReplicasMaxLag pulumi.IntPtrInput `pulumi:"minReplicasMaxLag"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringPtrInput `pulumi:"monitoringInstanceId"` + // The notify keyspace events. + NotifyKeyspaceEvents pulumi.StringPtrInput `pulumi:"notifyKeyspaceEvents"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringPtrInput `pulumi:"sgwAcl"` + // The snapshot configuration. + Snapshot pulumi.StringPtrInput `pulumi:"snapshot"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // TLS cipher suites to use. + TlsCiphersuites pulumi.StringPtrInput `pulumi:"tlsCiphersuites"` + // TLS protocol to use. + TlsProtocols pulumi.StringPtrInput `pulumi:"tlsProtocols"` +} + +func (RedisInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RedisInstanceParameters)(nil)).Elem() +} + +func (i RedisInstanceParametersArgs) ToRedisInstanceParametersOutput() RedisInstanceParametersOutput { + return i.ToRedisInstanceParametersOutputWithContext(context.Background()) +} + +func (i RedisInstanceParametersArgs) ToRedisInstanceParametersOutputWithContext(ctx context.Context) RedisInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceParametersOutput) +} + +func (i RedisInstanceParametersArgs) ToRedisInstanceParametersPtrOutput() RedisInstanceParametersPtrOutput { + return i.ToRedisInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i RedisInstanceParametersArgs) ToRedisInstanceParametersPtrOutputWithContext(ctx context.Context) RedisInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceParametersOutput).ToRedisInstanceParametersPtrOutputWithContext(ctx) +} + +// RedisInstanceParametersPtrInput is an input type that accepts RedisInstanceParametersArgs, RedisInstanceParametersPtr and RedisInstanceParametersPtrOutput values. +// You can construct a concrete instance of `RedisInstanceParametersPtrInput` via: +// +// RedisInstanceParametersArgs{...} +// +// or: +// +// nil +type RedisInstanceParametersPtrInput interface { + pulumi.Input + + ToRedisInstanceParametersPtrOutput() RedisInstanceParametersPtrOutput + ToRedisInstanceParametersPtrOutputWithContext(context.Context) RedisInstanceParametersPtrOutput +} + +type redisInstanceParametersPtrType RedisInstanceParametersArgs + +func RedisInstanceParametersPtr(v *RedisInstanceParametersArgs) RedisInstanceParametersPtrInput { + return (*redisInstanceParametersPtrType)(v) +} + +func (*redisInstanceParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RedisInstanceParameters)(nil)).Elem() +} + +func (i *redisInstanceParametersPtrType) ToRedisInstanceParametersPtrOutput() RedisInstanceParametersPtrOutput { + return i.ToRedisInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (i *redisInstanceParametersPtrType) ToRedisInstanceParametersPtrOutputWithContext(ctx context.Context) RedisInstanceParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceParametersPtrOutput) +} + +type RedisInstanceParametersOutput struct{ *pulumi.OutputState } + +func (RedisInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RedisInstanceParameters)(nil)).Elem() +} + +func (o RedisInstanceParametersOutput) ToRedisInstanceParametersOutput() RedisInstanceParametersOutput { + return o +} + +func (o RedisInstanceParametersOutput) ToRedisInstanceParametersOutputWithContext(ctx context.Context) RedisInstanceParametersOutput { + return o +} + +func (o RedisInstanceParametersOutput) ToRedisInstanceParametersPtrOutput() RedisInstanceParametersPtrOutput { + return o.ToRedisInstanceParametersPtrOutputWithContext(context.Background()) +} + +func (o RedisInstanceParametersOutput) ToRedisInstanceParametersPtrOutputWithContext(ctx context.Context) RedisInstanceParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RedisInstanceParameters) *RedisInstanceParameters { + return &v + }).(RedisInstanceParametersPtrOutput) +} + +// The number of milliseconds after which the instance is considered down. +func (o RedisInstanceParametersOutput) DownAfterMilliseconds() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.DownAfterMilliseconds }).(pulumi.IntPtrOutput) +} + +// Enable monitoring. +func (o RedisInstanceParametersOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *bool { return v.EnableMonitoring }).(pulumi.BoolPtrOutput) +} + +// The failover timeout in milliseconds. +func (o RedisInstanceParametersOutput) FailoverTimeout() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.FailoverTimeout }).(pulumi.IntPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o RedisInstanceParametersOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.Graphite }).(pulumi.StringPtrOutput) +} + +// The lazy eviction enablement (yes or no). +func (o RedisInstanceParametersOutput) LazyfreeLazyEviction() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.LazyfreeLazyEviction }).(pulumi.StringPtrOutput) +} + +// The lazy expire enablement (yes or no). +func (o RedisInstanceParametersOutput) LazyfreeLazyExpire() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.LazyfreeLazyExpire }).(pulumi.StringPtrOutput) +} + +// The Lua time limit. +func (o RedisInstanceParametersOutput) LuaTimeLimit() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.LuaTimeLimit }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o RedisInstanceParametersOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.MaxDiskThreshold }).(pulumi.IntPtrOutput) +} + +// The maximum number of clients. +func (o RedisInstanceParametersOutput) Maxclients() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.Maxclients }).(pulumi.IntPtrOutput) +} + +// The policy to handle the maximum memory (volatile-lru, noeviction, etc). +func (o RedisInstanceParametersOutput) MaxmemoryPolicy() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.MaxmemoryPolicy }).(pulumi.StringPtrOutput) +} + +// The maximum memory samples. +func (o RedisInstanceParametersOutput) MaxmemorySamples() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.MaxmemorySamples }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o RedisInstanceParametersOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.MetricsFrequency }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o RedisInstanceParametersOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.MetricsPrefix }).(pulumi.StringPtrOutput) +} + +// The minimum replicas maximum lag. +func (o RedisInstanceParametersOutput) MinReplicasMaxLag() pulumi.IntPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *int { return v.MinReplicasMaxLag }).(pulumi.IntPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o RedisInstanceParametersOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.MonitoringInstanceId }).(pulumi.StringPtrOutput) +} + +// The notify keyspace events. +func (o RedisInstanceParametersOutput) NotifyKeyspaceEvents() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.NotifyKeyspaceEvents }).(pulumi.StringPtrOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o RedisInstanceParametersOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.SgwAcl }).(pulumi.StringPtrOutput) +} + +// The snapshot configuration. +func (o RedisInstanceParametersOutput) Snapshot() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.Snapshot }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o RedisInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v RedisInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o RedisInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v RedisInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// TLS cipher suites to use. +func (o RedisInstanceParametersOutput) TlsCiphersuites() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.TlsCiphersuites }).(pulumi.StringPtrOutput) +} + +// TLS protocol to use. +func (o RedisInstanceParametersOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v RedisInstanceParameters) *string { return v.TlsProtocols }).(pulumi.StringPtrOutput) +} + +type RedisInstanceParametersPtrOutput struct{ *pulumi.OutputState } + +func (RedisInstanceParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RedisInstanceParameters)(nil)).Elem() +} + +func (o RedisInstanceParametersPtrOutput) ToRedisInstanceParametersPtrOutput() RedisInstanceParametersPtrOutput { + return o +} + +func (o RedisInstanceParametersPtrOutput) ToRedisInstanceParametersPtrOutputWithContext(ctx context.Context) RedisInstanceParametersPtrOutput { + return o +} + +func (o RedisInstanceParametersPtrOutput) Elem() RedisInstanceParametersOutput { + return o.ApplyT(func(v *RedisInstanceParameters) RedisInstanceParameters { + if v != nil { + return *v + } + var ret RedisInstanceParameters + return ret + }).(RedisInstanceParametersOutput) +} + +// The number of milliseconds after which the instance is considered down. +func (o RedisInstanceParametersPtrOutput) DownAfterMilliseconds() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.DownAfterMilliseconds + }).(pulumi.IntPtrOutput) +} + +// Enable monitoring. +func (o RedisInstanceParametersPtrOutput) EnableMonitoring() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *bool { + if v == nil { + return nil + } + return v.EnableMonitoring + }).(pulumi.BoolPtrOutput) +} + +// The failover timeout in milliseconds. +func (o RedisInstanceParametersPtrOutput) FailoverTimeout() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.FailoverTimeout + }).(pulumi.IntPtrOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o RedisInstanceParametersPtrOutput) Graphite() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.Graphite + }).(pulumi.StringPtrOutput) +} + +// The lazy eviction enablement (yes or no). +func (o RedisInstanceParametersPtrOutput) LazyfreeLazyEviction() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.LazyfreeLazyEviction + }).(pulumi.StringPtrOutput) +} + +// The lazy expire enablement (yes or no). +func (o RedisInstanceParametersPtrOutput) LazyfreeLazyExpire() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.LazyfreeLazyExpire + }).(pulumi.StringPtrOutput) +} + +// The Lua time limit. +func (o RedisInstanceParametersPtrOutput) LuaTimeLimit() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.LuaTimeLimit + }).(pulumi.IntPtrOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o RedisInstanceParametersPtrOutput) MaxDiskThreshold() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxDiskThreshold + }).(pulumi.IntPtrOutput) +} + +// The maximum number of clients. +func (o RedisInstanceParametersPtrOutput) Maxclients() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.Maxclients + }).(pulumi.IntPtrOutput) +} + +// The policy to handle the maximum memory (volatile-lru, noeviction, etc). +func (o RedisInstanceParametersPtrOutput) MaxmemoryPolicy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.MaxmemoryPolicy + }).(pulumi.StringPtrOutput) +} + +// The maximum memory samples. +func (o RedisInstanceParametersPtrOutput) MaxmemorySamples() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.MaxmemorySamples + }).(pulumi.IntPtrOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o RedisInstanceParametersPtrOutput) MetricsFrequency() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.MetricsFrequency + }).(pulumi.IntPtrOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o RedisInstanceParametersPtrOutput) MetricsPrefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.MetricsPrefix + }).(pulumi.StringPtrOutput) +} + +// The minimum replicas maximum lag. +func (o RedisInstanceParametersPtrOutput) MinReplicasMaxLag() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *int { + if v == nil { + return nil + } + return v.MinReplicasMaxLag + }).(pulumi.IntPtrOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o RedisInstanceParametersPtrOutput) MonitoringInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.MonitoringInstanceId + }).(pulumi.StringPtrOutput) +} + +// The notify keyspace events. +func (o RedisInstanceParametersPtrOutput) NotifyKeyspaceEvents() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.NotifyKeyspaceEvents + }).(pulumi.StringPtrOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o RedisInstanceParametersPtrOutput) SgwAcl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.SgwAcl + }).(pulumi.StringPtrOutput) +} + +// The snapshot configuration. +func (o RedisInstanceParametersPtrOutput) Snapshot() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.Snapshot + }).(pulumi.StringPtrOutput) +} + +// List of syslog servers to send logs to. +func (o RedisInstanceParametersPtrOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RedisInstanceParameters) []string { + if v == nil { + return nil + } + return v.Syslogs + }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o RedisInstanceParametersPtrOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RedisInstanceParameters) []string { + if v == nil { + return nil + } + return v.TlsCiphers + }).(pulumi.StringArrayOutput) +} + +// TLS cipher suites to use. +func (o RedisInstanceParametersPtrOutput) TlsCiphersuites() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.TlsCiphersuites + }).(pulumi.StringPtrOutput) +} + +// TLS protocol to use. +func (o RedisInstanceParametersPtrOutput) TlsProtocols() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RedisInstanceParameters) *string { + if v == nil { + return nil + } + return v.TlsProtocols + }).(pulumi.StringPtrOutput) +} + +type SecurityGroupRuleIcmpParameters struct { + // ICMP code. Can be set if the protocol is ICMP. + Code int `pulumi:"code"` + // ICMP type. Can be set if the protocol is ICMP. + Type int `pulumi:"type"` +} + +// SecurityGroupRuleIcmpParametersInput is an input type that accepts SecurityGroupRuleIcmpParametersArgs and SecurityGroupRuleIcmpParametersOutput values. +// You can construct a concrete instance of `SecurityGroupRuleIcmpParametersInput` via: +// +// SecurityGroupRuleIcmpParametersArgs{...} +type SecurityGroupRuleIcmpParametersInput interface { + pulumi.Input + + ToSecurityGroupRuleIcmpParametersOutput() SecurityGroupRuleIcmpParametersOutput + ToSecurityGroupRuleIcmpParametersOutputWithContext(context.Context) SecurityGroupRuleIcmpParametersOutput +} + +type SecurityGroupRuleIcmpParametersArgs struct { + // ICMP code. Can be set if the protocol is ICMP. + Code pulumi.IntInput `pulumi:"code"` + // ICMP type. Can be set if the protocol is ICMP. + Type pulumi.IntInput `pulumi:"type"` +} + +func (SecurityGroupRuleIcmpParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (i SecurityGroupRuleIcmpParametersArgs) ToSecurityGroupRuleIcmpParametersOutput() SecurityGroupRuleIcmpParametersOutput { + return i.ToSecurityGroupRuleIcmpParametersOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleIcmpParametersArgs) ToSecurityGroupRuleIcmpParametersOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleIcmpParametersOutput) +} + +func (i SecurityGroupRuleIcmpParametersArgs) ToSecurityGroupRuleIcmpParametersPtrOutput() SecurityGroupRuleIcmpParametersPtrOutput { + return i.ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleIcmpParametersArgs) ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleIcmpParametersOutput).ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(ctx) +} + +// SecurityGroupRuleIcmpParametersPtrInput is an input type that accepts SecurityGroupRuleIcmpParametersArgs, SecurityGroupRuleIcmpParametersPtr and SecurityGroupRuleIcmpParametersPtrOutput values. +// You can construct a concrete instance of `SecurityGroupRuleIcmpParametersPtrInput` via: +// +// SecurityGroupRuleIcmpParametersArgs{...} +// +// or: +// +// nil +type SecurityGroupRuleIcmpParametersPtrInput interface { + pulumi.Input + + ToSecurityGroupRuleIcmpParametersPtrOutput() SecurityGroupRuleIcmpParametersPtrOutput + ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(context.Context) SecurityGroupRuleIcmpParametersPtrOutput +} + +type securityGroupRuleIcmpParametersPtrType SecurityGroupRuleIcmpParametersArgs + +func SecurityGroupRuleIcmpParametersPtr(v *SecurityGroupRuleIcmpParametersArgs) SecurityGroupRuleIcmpParametersPtrInput { + return (*securityGroupRuleIcmpParametersPtrType)(v) +} + +func (*securityGroupRuleIcmpParametersPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (i *securityGroupRuleIcmpParametersPtrType) ToSecurityGroupRuleIcmpParametersPtrOutput() SecurityGroupRuleIcmpParametersPtrOutput { + return i.ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(context.Background()) +} + +func (i *securityGroupRuleIcmpParametersPtrType) ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleIcmpParametersPtrOutput) +} + +type SecurityGroupRuleIcmpParametersOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleIcmpParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (o SecurityGroupRuleIcmpParametersOutput) ToSecurityGroupRuleIcmpParametersOutput() SecurityGroupRuleIcmpParametersOutput { + return o +} + +func (o SecurityGroupRuleIcmpParametersOutput) ToSecurityGroupRuleIcmpParametersOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersOutput { + return o +} + +func (o SecurityGroupRuleIcmpParametersOutput) ToSecurityGroupRuleIcmpParametersPtrOutput() SecurityGroupRuleIcmpParametersPtrOutput { + return o.ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(context.Background()) +} + +func (o SecurityGroupRuleIcmpParametersOutput) ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SecurityGroupRuleIcmpParameters) *SecurityGroupRuleIcmpParameters { + return &v + }).(SecurityGroupRuleIcmpParametersPtrOutput) +} + +// ICMP code. Can be set if the protocol is ICMP. +func (o SecurityGroupRuleIcmpParametersOutput) Code() pulumi.IntOutput { + return o.ApplyT(func(v SecurityGroupRuleIcmpParameters) int { return v.Code }).(pulumi.IntOutput) +} + +// ICMP type. Can be set if the protocol is ICMP. +func (o SecurityGroupRuleIcmpParametersOutput) Type() pulumi.IntOutput { + return o.ApplyT(func(v SecurityGroupRuleIcmpParameters) int { return v.Type }).(pulumi.IntOutput) +} + +type SecurityGroupRuleIcmpParametersPtrOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleIcmpParametersPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (o SecurityGroupRuleIcmpParametersPtrOutput) ToSecurityGroupRuleIcmpParametersPtrOutput() SecurityGroupRuleIcmpParametersPtrOutput { + return o +} + +func (o SecurityGroupRuleIcmpParametersPtrOutput) ToSecurityGroupRuleIcmpParametersPtrOutputWithContext(ctx context.Context) SecurityGroupRuleIcmpParametersPtrOutput { + return o +} + +func (o SecurityGroupRuleIcmpParametersPtrOutput) Elem() SecurityGroupRuleIcmpParametersOutput { + return o.ApplyT(func(v *SecurityGroupRuleIcmpParameters) SecurityGroupRuleIcmpParameters { + if v != nil { + return *v + } + var ret SecurityGroupRuleIcmpParameters + return ret + }).(SecurityGroupRuleIcmpParametersOutput) +} + +// ICMP code. Can be set if the protocol is ICMP. +func (o SecurityGroupRuleIcmpParametersPtrOutput) Code() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SecurityGroupRuleIcmpParameters) *int { + if v == nil { + return nil + } + return &v.Code + }).(pulumi.IntPtrOutput) +} + +// ICMP type. Can be set if the protocol is ICMP. +func (o SecurityGroupRuleIcmpParametersPtrOutput) Type() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SecurityGroupRuleIcmpParameters) *int { + if v == nil { + return nil + } + return &v.Type + }).(pulumi.IntPtrOutput) +} + +type SecurityGroupRulePortRange struct { + // The maximum port number. Should be greater or equal to the minimum. + Max int `pulumi:"max"` + // The minimum port number. Should be less or equal to the maximum. + Min int `pulumi:"min"` +} + +// SecurityGroupRulePortRangeInput is an input type that accepts SecurityGroupRulePortRangeArgs and SecurityGroupRulePortRangeOutput values. +// You can construct a concrete instance of `SecurityGroupRulePortRangeInput` via: +// +// SecurityGroupRulePortRangeArgs{...} +type SecurityGroupRulePortRangeInput interface { + pulumi.Input + + ToSecurityGroupRulePortRangeOutput() SecurityGroupRulePortRangeOutput + ToSecurityGroupRulePortRangeOutputWithContext(context.Context) SecurityGroupRulePortRangeOutput +} + +type SecurityGroupRulePortRangeArgs struct { + // The maximum port number. Should be greater or equal to the minimum. + Max pulumi.IntInput `pulumi:"max"` + // The minimum port number. Should be less or equal to the maximum. + Min pulumi.IntInput `pulumi:"min"` +} + +func (SecurityGroupRulePortRangeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRulePortRange)(nil)).Elem() +} + +func (i SecurityGroupRulePortRangeArgs) ToSecurityGroupRulePortRangeOutput() SecurityGroupRulePortRangeOutput { + return i.ToSecurityGroupRulePortRangeOutputWithContext(context.Background()) +} + +func (i SecurityGroupRulePortRangeArgs) ToSecurityGroupRulePortRangeOutputWithContext(ctx context.Context) SecurityGroupRulePortRangeOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRulePortRangeOutput) +} + +func (i SecurityGroupRulePortRangeArgs) ToSecurityGroupRulePortRangePtrOutput() SecurityGroupRulePortRangePtrOutput { + return i.ToSecurityGroupRulePortRangePtrOutputWithContext(context.Background()) +} + +func (i SecurityGroupRulePortRangeArgs) ToSecurityGroupRulePortRangePtrOutputWithContext(ctx context.Context) SecurityGroupRulePortRangePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRulePortRangeOutput).ToSecurityGroupRulePortRangePtrOutputWithContext(ctx) +} + +// SecurityGroupRulePortRangePtrInput is an input type that accepts SecurityGroupRulePortRangeArgs, SecurityGroupRulePortRangePtr and SecurityGroupRulePortRangePtrOutput values. +// You can construct a concrete instance of `SecurityGroupRulePortRangePtrInput` via: +// +// SecurityGroupRulePortRangeArgs{...} +// +// or: +// +// nil +type SecurityGroupRulePortRangePtrInput interface { + pulumi.Input + + ToSecurityGroupRulePortRangePtrOutput() SecurityGroupRulePortRangePtrOutput + ToSecurityGroupRulePortRangePtrOutputWithContext(context.Context) SecurityGroupRulePortRangePtrOutput +} + +type securityGroupRulePortRangePtrType SecurityGroupRulePortRangeArgs + +func SecurityGroupRulePortRangePtr(v *SecurityGroupRulePortRangeArgs) SecurityGroupRulePortRangePtrInput { + return (*securityGroupRulePortRangePtrType)(v) +} + +func (*securityGroupRulePortRangePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRulePortRange)(nil)).Elem() +} + +func (i *securityGroupRulePortRangePtrType) ToSecurityGroupRulePortRangePtrOutput() SecurityGroupRulePortRangePtrOutput { + return i.ToSecurityGroupRulePortRangePtrOutputWithContext(context.Background()) +} + +func (i *securityGroupRulePortRangePtrType) ToSecurityGroupRulePortRangePtrOutputWithContext(ctx context.Context) SecurityGroupRulePortRangePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRulePortRangePtrOutput) +} + +type SecurityGroupRulePortRangeOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRulePortRangeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRulePortRange)(nil)).Elem() +} + +func (o SecurityGroupRulePortRangeOutput) ToSecurityGroupRulePortRangeOutput() SecurityGroupRulePortRangeOutput { + return o +} + +func (o SecurityGroupRulePortRangeOutput) ToSecurityGroupRulePortRangeOutputWithContext(ctx context.Context) SecurityGroupRulePortRangeOutput { + return o +} + +func (o SecurityGroupRulePortRangeOutput) ToSecurityGroupRulePortRangePtrOutput() SecurityGroupRulePortRangePtrOutput { + return o.ToSecurityGroupRulePortRangePtrOutputWithContext(context.Background()) +} + +func (o SecurityGroupRulePortRangeOutput) ToSecurityGroupRulePortRangePtrOutputWithContext(ctx context.Context) SecurityGroupRulePortRangePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SecurityGroupRulePortRange) *SecurityGroupRulePortRange { + return &v + }).(SecurityGroupRulePortRangePtrOutput) +} + +// The maximum port number. Should be greater or equal to the minimum. +func (o SecurityGroupRulePortRangeOutput) Max() pulumi.IntOutput { + return o.ApplyT(func(v SecurityGroupRulePortRange) int { return v.Max }).(pulumi.IntOutput) +} + +// The minimum port number. Should be less or equal to the maximum. +func (o SecurityGroupRulePortRangeOutput) Min() pulumi.IntOutput { + return o.ApplyT(func(v SecurityGroupRulePortRange) int { return v.Min }).(pulumi.IntOutput) +} + +type SecurityGroupRulePortRangePtrOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRulePortRangePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRulePortRange)(nil)).Elem() +} + +func (o SecurityGroupRulePortRangePtrOutput) ToSecurityGroupRulePortRangePtrOutput() SecurityGroupRulePortRangePtrOutput { + return o +} + +func (o SecurityGroupRulePortRangePtrOutput) ToSecurityGroupRulePortRangePtrOutputWithContext(ctx context.Context) SecurityGroupRulePortRangePtrOutput { + return o +} + +func (o SecurityGroupRulePortRangePtrOutput) Elem() SecurityGroupRulePortRangeOutput { + return o.ApplyT(func(v *SecurityGroupRulePortRange) SecurityGroupRulePortRange { + if v != nil { + return *v + } + var ret SecurityGroupRulePortRange + return ret + }).(SecurityGroupRulePortRangeOutput) +} + +// The maximum port number. Should be greater or equal to the minimum. +func (o SecurityGroupRulePortRangePtrOutput) Max() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SecurityGroupRulePortRange) *int { + if v == nil { + return nil + } + return &v.Max + }).(pulumi.IntPtrOutput) +} + +// The minimum port number. Should be less or equal to the maximum. +func (o SecurityGroupRulePortRangePtrOutput) Min() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SecurityGroupRulePortRange) *int { + if v == nil { + return nil + } + return &v.Min + }).(pulumi.IntPtrOutput) +} + +type SecurityGroupRuleProtocol struct { + // The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + Name *string `pulumi:"name"` + // The protocol number which the rule should match. Either `name` or `number` must be provided. + Number *int `pulumi:"number"` +} + +// SecurityGroupRuleProtocolInput is an input type that accepts SecurityGroupRuleProtocolArgs and SecurityGroupRuleProtocolOutput values. +// You can construct a concrete instance of `SecurityGroupRuleProtocolInput` via: +// +// SecurityGroupRuleProtocolArgs{...} +type SecurityGroupRuleProtocolInput interface { + pulumi.Input + + ToSecurityGroupRuleProtocolOutput() SecurityGroupRuleProtocolOutput + ToSecurityGroupRuleProtocolOutputWithContext(context.Context) SecurityGroupRuleProtocolOutput +} + +type SecurityGroupRuleProtocolArgs struct { + // The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + Name pulumi.StringPtrInput `pulumi:"name"` + // The protocol number which the rule should match. Either `name` or `number` must be provided. + Number pulumi.IntPtrInput `pulumi:"number"` +} + +func (SecurityGroupRuleProtocolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRuleProtocol)(nil)).Elem() +} + +func (i SecurityGroupRuleProtocolArgs) ToSecurityGroupRuleProtocolOutput() SecurityGroupRuleProtocolOutput { + return i.ToSecurityGroupRuleProtocolOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleProtocolArgs) ToSecurityGroupRuleProtocolOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleProtocolOutput) +} + +func (i SecurityGroupRuleProtocolArgs) ToSecurityGroupRuleProtocolPtrOutput() SecurityGroupRuleProtocolPtrOutput { + return i.ToSecurityGroupRuleProtocolPtrOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleProtocolArgs) ToSecurityGroupRuleProtocolPtrOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleProtocolOutput).ToSecurityGroupRuleProtocolPtrOutputWithContext(ctx) +} + +// SecurityGroupRuleProtocolPtrInput is an input type that accepts SecurityGroupRuleProtocolArgs, SecurityGroupRuleProtocolPtr and SecurityGroupRuleProtocolPtrOutput values. +// You can construct a concrete instance of `SecurityGroupRuleProtocolPtrInput` via: +// +// SecurityGroupRuleProtocolArgs{...} +// +// or: +// +// nil +type SecurityGroupRuleProtocolPtrInput interface { + pulumi.Input + + ToSecurityGroupRuleProtocolPtrOutput() SecurityGroupRuleProtocolPtrOutput + ToSecurityGroupRuleProtocolPtrOutputWithContext(context.Context) SecurityGroupRuleProtocolPtrOutput +} + +type securityGroupRuleProtocolPtrType SecurityGroupRuleProtocolArgs + +func SecurityGroupRuleProtocolPtr(v *SecurityGroupRuleProtocolArgs) SecurityGroupRuleProtocolPtrInput { + return (*securityGroupRuleProtocolPtrType)(v) +} + +func (*securityGroupRuleProtocolPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRuleProtocol)(nil)).Elem() +} + +func (i *securityGroupRuleProtocolPtrType) ToSecurityGroupRuleProtocolPtrOutput() SecurityGroupRuleProtocolPtrOutput { + return i.ToSecurityGroupRuleProtocolPtrOutputWithContext(context.Background()) +} + +func (i *securityGroupRuleProtocolPtrType) ToSecurityGroupRuleProtocolPtrOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleProtocolPtrOutput) +} + +type SecurityGroupRuleProtocolOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleProtocolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SecurityGroupRuleProtocol)(nil)).Elem() +} + +func (o SecurityGroupRuleProtocolOutput) ToSecurityGroupRuleProtocolOutput() SecurityGroupRuleProtocolOutput { + return o +} + +func (o SecurityGroupRuleProtocolOutput) ToSecurityGroupRuleProtocolOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolOutput { + return o +} + +func (o SecurityGroupRuleProtocolOutput) ToSecurityGroupRuleProtocolPtrOutput() SecurityGroupRuleProtocolPtrOutput { + return o.ToSecurityGroupRuleProtocolPtrOutputWithContext(context.Background()) +} + +func (o SecurityGroupRuleProtocolOutput) ToSecurityGroupRuleProtocolPtrOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SecurityGroupRuleProtocol) *SecurityGroupRuleProtocol { + return &v + }).(SecurityGroupRuleProtocolPtrOutput) +} + +// The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. +func (o SecurityGroupRuleProtocolOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v SecurityGroupRuleProtocol) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// The protocol number which the rule should match. Either `name` or `number` must be provided. +func (o SecurityGroupRuleProtocolOutput) Number() pulumi.IntPtrOutput { + return o.ApplyT(func(v SecurityGroupRuleProtocol) *int { return v.Number }).(pulumi.IntPtrOutput) +} + +type SecurityGroupRuleProtocolPtrOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleProtocolPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRuleProtocol)(nil)).Elem() +} + +func (o SecurityGroupRuleProtocolPtrOutput) ToSecurityGroupRuleProtocolPtrOutput() SecurityGroupRuleProtocolPtrOutput { + return o +} + +func (o SecurityGroupRuleProtocolPtrOutput) ToSecurityGroupRuleProtocolPtrOutputWithContext(ctx context.Context) SecurityGroupRuleProtocolPtrOutput { + return o +} + +func (o SecurityGroupRuleProtocolPtrOutput) Elem() SecurityGroupRuleProtocolOutput { + return o.ApplyT(func(v *SecurityGroupRuleProtocol) SecurityGroupRuleProtocol { + if v != nil { + return *v + } + var ret SecurityGroupRuleProtocol + return ret + }).(SecurityGroupRuleProtocolOutput) +} + +// The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. +func (o SecurityGroupRuleProtocolPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SecurityGroupRuleProtocol) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// The protocol number which the rule should match. Either `name` or `number` must be provided. +func (o SecurityGroupRuleProtocolPtrOutput) Number() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SecurityGroupRuleProtocol) *int { + if v == nil { + return nil + } + return v.Number + }).(pulumi.IntPtrOutput) +} + +type ServerBackupScheduleBackupProperties struct { + Name string `pulumi:"name"` + RetentionPeriod int `pulumi:"retentionPeriod"` + VolumeIds []string `pulumi:"volumeIds"` +} + +// ServerBackupScheduleBackupPropertiesInput is an input type that accepts ServerBackupScheduleBackupPropertiesArgs and ServerBackupScheduleBackupPropertiesOutput values. +// You can construct a concrete instance of `ServerBackupScheduleBackupPropertiesInput` via: +// +// ServerBackupScheduleBackupPropertiesArgs{...} +type ServerBackupScheduleBackupPropertiesInput interface { + pulumi.Input + + ToServerBackupScheduleBackupPropertiesOutput() ServerBackupScheduleBackupPropertiesOutput + ToServerBackupScheduleBackupPropertiesOutputWithContext(context.Context) ServerBackupScheduleBackupPropertiesOutput +} + +type ServerBackupScheduleBackupPropertiesArgs struct { + Name pulumi.StringInput `pulumi:"name"` + RetentionPeriod pulumi.IntInput `pulumi:"retentionPeriod"` + VolumeIds pulumi.StringArrayInput `pulumi:"volumeIds"` +} + +func (ServerBackupScheduleBackupPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (i ServerBackupScheduleBackupPropertiesArgs) ToServerBackupScheduleBackupPropertiesOutput() ServerBackupScheduleBackupPropertiesOutput { + return i.ToServerBackupScheduleBackupPropertiesOutputWithContext(context.Background()) +} + +func (i ServerBackupScheduleBackupPropertiesArgs) ToServerBackupScheduleBackupPropertiesOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleBackupPropertiesOutput) +} + +func (i ServerBackupScheduleBackupPropertiesArgs) ToServerBackupScheduleBackupPropertiesPtrOutput() ServerBackupScheduleBackupPropertiesPtrOutput { + return i.ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(context.Background()) +} + +func (i ServerBackupScheduleBackupPropertiesArgs) ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleBackupPropertiesOutput).ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(ctx) +} + +// ServerBackupScheduleBackupPropertiesPtrInput is an input type that accepts ServerBackupScheduleBackupPropertiesArgs, ServerBackupScheduleBackupPropertiesPtr and ServerBackupScheduleBackupPropertiesPtrOutput values. +// You can construct a concrete instance of `ServerBackupScheduleBackupPropertiesPtrInput` via: +// +// ServerBackupScheduleBackupPropertiesArgs{...} +// +// or: +// +// nil +type ServerBackupScheduleBackupPropertiesPtrInput interface { + pulumi.Input + + ToServerBackupScheduleBackupPropertiesPtrOutput() ServerBackupScheduleBackupPropertiesPtrOutput + ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(context.Context) ServerBackupScheduleBackupPropertiesPtrOutput +} + +type serverBackupScheduleBackupPropertiesPtrType ServerBackupScheduleBackupPropertiesArgs + +func ServerBackupScheduleBackupPropertiesPtr(v *ServerBackupScheduleBackupPropertiesArgs) ServerBackupScheduleBackupPropertiesPtrInput { + return (*serverBackupScheduleBackupPropertiesPtrType)(v) +} + +func (*serverBackupScheduleBackupPropertiesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (i *serverBackupScheduleBackupPropertiesPtrType) ToServerBackupScheduleBackupPropertiesPtrOutput() ServerBackupScheduleBackupPropertiesPtrOutput { + return i.ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(context.Background()) +} + +func (i *serverBackupScheduleBackupPropertiesPtrType) ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleBackupPropertiesPtrOutput) +} + +type ServerBackupScheduleBackupPropertiesOutput struct{ *pulumi.OutputState } + +func (ServerBackupScheduleBackupPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (o ServerBackupScheduleBackupPropertiesOutput) ToServerBackupScheduleBackupPropertiesOutput() ServerBackupScheduleBackupPropertiesOutput { + return o +} + +func (o ServerBackupScheduleBackupPropertiesOutput) ToServerBackupScheduleBackupPropertiesOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesOutput { + return o +} + +func (o ServerBackupScheduleBackupPropertiesOutput) ToServerBackupScheduleBackupPropertiesPtrOutput() ServerBackupScheduleBackupPropertiesPtrOutput { + return o.ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(context.Background()) +} + +func (o ServerBackupScheduleBackupPropertiesOutput) ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ServerBackupScheduleBackupProperties) *ServerBackupScheduleBackupProperties { + return &v + }).(ServerBackupScheduleBackupPropertiesPtrOutput) +} + +func (o ServerBackupScheduleBackupPropertiesOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v ServerBackupScheduleBackupProperties) string { return v.Name }).(pulumi.StringOutput) +} + +func (o ServerBackupScheduleBackupPropertiesOutput) RetentionPeriod() pulumi.IntOutput { + return o.ApplyT(func(v ServerBackupScheduleBackupProperties) int { return v.RetentionPeriod }).(pulumi.IntOutput) +} + +func (o ServerBackupScheduleBackupPropertiesOutput) VolumeIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v ServerBackupScheduleBackupProperties) []string { return v.VolumeIds }).(pulumi.StringArrayOutput) +} + +type ServerBackupScheduleBackupPropertiesPtrOutput struct{ *pulumi.OutputState } + +func (ServerBackupScheduleBackupPropertiesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) ToServerBackupScheduleBackupPropertiesPtrOutput() ServerBackupScheduleBackupPropertiesPtrOutput { + return o +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) ToServerBackupScheduleBackupPropertiesPtrOutputWithContext(ctx context.Context) ServerBackupScheduleBackupPropertiesPtrOutput { + return o +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) Elem() ServerBackupScheduleBackupPropertiesOutput { + return o.ApplyT(func(v *ServerBackupScheduleBackupProperties) ServerBackupScheduleBackupProperties { + if v != nil { + return *v + } + var ret ServerBackupScheduleBackupProperties + return ret + }).(ServerBackupScheduleBackupPropertiesOutput) +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServerBackupScheduleBackupProperties) *string { + if v == nil { + return nil + } + return &v.Name + }).(pulumi.StringPtrOutput) +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) RetentionPeriod() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ServerBackupScheduleBackupProperties) *int { + if v == nil { + return nil + } + return &v.RetentionPeriod + }).(pulumi.IntPtrOutput) +} + +func (o ServerBackupScheduleBackupPropertiesPtrOutput) VolumeIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ServerBackupScheduleBackupProperties) []string { + if v == nil { + return nil + } + return v.VolumeIds + }).(pulumi.StringArrayOutput) +} + +type ServerBootVolume struct { + // Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. + DeleteOnTermination *bool `pulumi:"deleteOnTermination"` + // The ID of the boot volume + Id *string `pulumi:"id"` + // The performance class of the server. + PerformanceClass *string `pulumi:"performanceClass"` + // The size of the boot volume in GB. Must be provided when `sourceType` is `image`. + Size *int `pulumi:"size"` + // The ID of the source, either image ID or volume ID + SourceId string `pulumi:"sourceId"` + // The type of the source. Supported values are: `volume`, `image`. + SourceType string `pulumi:"sourceType"` +} + +// ServerBootVolumeInput is an input type that accepts ServerBootVolumeArgs and ServerBootVolumeOutput values. +// You can construct a concrete instance of `ServerBootVolumeInput` via: +// +// ServerBootVolumeArgs{...} +type ServerBootVolumeInput interface { + pulumi.Input + + ToServerBootVolumeOutput() ServerBootVolumeOutput + ToServerBootVolumeOutputWithContext(context.Context) ServerBootVolumeOutput +} + +type ServerBootVolumeArgs struct { + // Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. + DeleteOnTermination pulumi.BoolPtrInput `pulumi:"deleteOnTermination"` + // The ID of the boot volume + Id pulumi.StringPtrInput `pulumi:"id"` + // The performance class of the server. + PerformanceClass pulumi.StringPtrInput `pulumi:"performanceClass"` + // The size of the boot volume in GB. Must be provided when `sourceType` is `image`. + Size pulumi.IntPtrInput `pulumi:"size"` + // The ID of the source, either image ID or volume ID + SourceId pulumi.StringInput `pulumi:"sourceId"` + // The type of the source. Supported values are: `volume`, `image`. + SourceType pulumi.StringInput `pulumi:"sourceType"` +} + +func (ServerBootVolumeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ServerBootVolume)(nil)).Elem() +} + +func (i ServerBootVolumeArgs) ToServerBootVolumeOutput() ServerBootVolumeOutput { + return i.ToServerBootVolumeOutputWithContext(context.Background()) +} + +func (i ServerBootVolumeArgs) ToServerBootVolumeOutputWithContext(ctx context.Context) ServerBootVolumeOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBootVolumeOutput) +} + +func (i ServerBootVolumeArgs) ToServerBootVolumePtrOutput() ServerBootVolumePtrOutput { + return i.ToServerBootVolumePtrOutputWithContext(context.Background()) +} + +func (i ServerBootVolumeArgs) ToServerBootVolumePtrOutputWithContext(ctx context.Context) ServerBootVolumePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBootVolumeOutput).ToServerBootVolumePtrOutputWithContext(ctx) +} + +// ServerBootVolumePtrInput is an input type that accepts ServerBootVolumeArgs, ServerBootVolumePtr and ServerBootVolumePtrOutput values. +// You can construct a concrete instance of `ServerBootVolumePtrInput` via: +// +// ServerBootVolumeArgs{...} +// +// or: +// +// nil +type ServerBootVolumePtrInput interface { + pulumi.Input + + ToServerBootVolumePtrOutput() ServerBootVolumePtrOutput + ToServerBootVolumePtrOutputWithContext(context.Context) ServerBootVolumePtrOutput +} + +type serverBootVolumePtrType ServerBootVolumeArgs + +func ServerBootVolumePtr(v *ServerBootVolumeArgs) ServerBootVolumePtrInput { + return (*serverBootVolumePtrType)(v) +} + +func (*serverBootVolumePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBootVolume)(nil)).Elem() +} + +func (i *serverBootVolumePtrType) ToServerBootVolumePtrOutput() ServerBootVolumePtrOutput { + return i.ToServerBootVolumePtrOutputWithContext(context.Background()) +} + +func (i *serverBootVolumePtrType) ToServerBootVolumePtrOutputWithContext(ctx context.Context) ServerBootVolumePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBootVolumePtrOutput) +} + +type ServerBootVolumeOutput struct{ *pulumi.OutputState } + +func (ServerBootVolumeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ServerBootVolume)(nil)).Elem() +} + +func (o ServerBootVolumeOutput) ToServerBootVolumeOutput() ServerBootVolumeOutput { + return o +} + +func (o ServerBootVolumeOutput) ToServerBootVolumeOutputWithContext(ctx context.Context) ServerBootVolumeOutput { + return o +} + +func (o ServerBootVolumeOutput) ToServerBootVolumePtrOutput() ServerBootVolumePtrOutput { + return o.ToServerBootVolumePtrOutputWithContext(context.Background()) +} + +func (o ServerBootVolumeOutput) ToServerBootVolumePtrOutputWithContext(ctx context.Context) ServerBootVolumePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ServerBootVolume) *ServerBootVolume { + return &v + }).(ServerBootVolumePtrOutput) +} + +// Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. +func (o ServerBootVolumeOutput) DeleteOnTermination() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ServerBootVolume) *bool { return v.DeleteOnTermination }).(pulumi.BoolPtrOutput) +} + +// The ID of the boot volume +func (o ServerBootVolumeOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v ServerBootVolume) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// The performance class of the server. +func (o ServerBootVolumeOutput) PerformanceClass() pulumi.StringPtrOutput { + return o.ApplyT(func(v ServerBootVolume) *string { return v.PerformanceClass }).(pulumi.StringPtrOutput) +} + +// The size of the boot volume in GB. Must be provided when `sourceType` is `image`. +func (o ServerBootVolumeOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v ServerBootVolume) *int { return v.Size }).(pulumi.IntPtrOutput) +} + +// The ID of the source, either image ID or volume ID +func (o ServerBootVolumeOutput) SourceId() pulumi.StringOutput { + return o.ApplyT(func(v ServerBootVolume) string { return v.SourceId }).(pulumi.StringOutput) +} + +// The type of the source. Supported values are: `volume`, `image`. +func (o ServerBootVolumeOutput) SourceType() pulumi.StringOutput { + return o.ApplyT(func(v ServerBootVolume) string { return v.SourceType }).(pulumi.StringOutput) +} + +type ServerBootVolumePtrOutput struct{ *pulumi.OutputState } + +func (ServerBootVolumePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBootVolume)(nil)).Elem() +} + +func (o ServerBootVolumePtrOutput) ToServerBootVolumePtrOutput() ServerBootVolumePtrOutput { + return o +} + +func (o ServerBootVolumePtrOutput) ToServerBootVolumePtrOutputWithContext(ctx context.Context) ServerBootVolumePtrOutput { + return o +} + +func (o ServerBootVolumePtrOutput) Elem() ServerBootVolumeOutput { + return o.ApplyT(func(v *ServerBootVolume) ServerBootVolume { + if v != nil { + return *v + } + var ret ServerBootVolume + return ret + }).(ServerBootVolumeOutput) +} + +// Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. +func (o ServerBootVolumePtrOutput) DeleteOnTermination() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *bool { + if v == nil { + return nil + } + return v.DeleteOnTermination + }).(pulumi.BoolPtrOutput) +} + +// The ID of the boot volume +func (o ServerBootVolumePtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *string { + if v == nil { + return nil + } + return v.Id + }).(pulumi.StringPtrOutput) +} + +// The performance class of the server. +func (o ServerBootVolumePtrOutput) PerformanceClass() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *string { + if v == nil { + return nil + } + return v.PerformanceClass + }).(pulumi.StringPtrOutput) +} + +// The size of the boot volume in GB. Must be provided when `sourceType` is `image`. +func (o ServerBootVolumePtrOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *int { + if v == nil { + return nil + } + return v.Size + }).(pulumi.IntPtrOutput) +} + +// The ID of the source, either image ID or volume ID +func (o ServerBootVolumePtrOutput) SourceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *string { + if v == nil { + return nil + } + return &v.SourceId + }).(pulumi.StringPtrOutput) +} + +// The type of the source. Supported values are: `volume`, `image`. +func (o ServerBootVolumePtrOutput) SourceType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServerBootVolume) *string { + if v == nil { + return nil + } + return &v.SourceType + }).(pulumi.StringPtrOutput) +} + +type SkeClusterExtensions struct { + // Cluster access control configuration. + Acl *SkeClusterExtensionsAcl `pulumi:"acl"` + // A single argus block as defined below. + Argus *SkeClusterExtensionsArgus `pulumi:"argus"` + // DNS extension configuration + Dns *SkeClusterExtensionsDns `pulumi:"dns"` +} + +// SkeClusterExtensionsInput is an input type that accepts SkeClusterExtensionsArgs and SkeClusterExtensionsOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsInput` via: +// +// SkeClusterExtensionsArgs{...} +type SkeClusterExtensionsInput interface { + pulumi.Input + + ToSkeClusterExtensionsOutput() SkeClusterExtensionsOutput + ToSkeClusterExtensionsOutputWithContext(context.Context) SkeClusterExtensionsOutput +} + +type SkeClusterExtensionsArgs struct { + // Cluster access control configuration. + Acl SkeClusterExtensionsAclPtrInput `pulumi:"acl"` + // A single argus block as defined below. + Argus SkeClusterExtensionsArgusPtrInput `pulumi:"argus"` + // DNS extension configuration + Dns SkeClusterExtensionsDnsPtrInput `pulumi:"dns"` +} + +func (SkeClusterExtensionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensions)(nil)).Elem() +} + +func (i SkeClusterExtensionsArgs) ToSkeClusterExtensionsOutput() SkeClusterExtensionsOutput { + return i.ToSkeClusterExtensionsOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsArgs) ToSkeClusterExtensionsOutputWithContext(ctx context.Context) SkeClusterExtensionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsOutput) +} + +func (i SkeClusterExtensionsArgs) ToSkeClusterExtensionsPtrOutput() SkeClusterExtensionsPtrOutput { + return i.ToSkeClusterExtensionsPtrOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsArgs) ToSkeClusterExtensionsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsOutput).ToSkeClusterExtensionsPtrOutputWithContext(ctx) +} + +// SkeClusterExtensionsPtrInput is an input type that accepts SkeClusterExtensionsArgs, SkeClusterExtensionsPtr and SkeClusterExtensionsPtrOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsPtrInput` via: +// +// SkeClusterExtensionsArgs{...} +// +// or: +// +// nil +type SkeClusterExtensionsPtrInput interface { + pulumi.Input + + ToSkeClusterExtensionsPtrOutput() SkeClusterExtensionsPtrOutput + ToSkeClusterExtensionsPtrOutputWithContext(context.Context) SkeClusterExtensionsPtrOutput +} + +type skeClusterExtensionsPtrType SkeClusterExtensionsArgs + +func SkeClusterExtensionsPtr(v *SkeClusterExtensionsArgs) SkeClusterExtensionsPtrInput { + return (*skeClusterExtensionsPtrType)(v) +} + +func (*skeClusterExtensionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensions)(nil)).Elem() +} + +func (i *skeClusterExtensionsPtrType) ToSkeClusterExtensionsPtrOutput() SkeClusterExtensionsPtrOutput { + return i.ToSkeClusterExtensionsPtrOutputWithContext(context.Background()) +} + +func (i *skeClusterExtensionsPtrType) ToSkeClusterExtensionsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsPtrOutput) +} + +type SkeClusterExtensionsOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensions)(nil)).Elem() +} + +func (o SkeClusterExtensionsOutput) ToSkeClusterExtensionsOutput() SkeClusterExtensionsOutput { + return o +} + +func (o SkeClusterExtensionsOutput) ToSkeClusterExtensionsOutputWithContext(ctx context.Context) SkeClusterExtensionsOutput { + return o +} + +func (o SkeClusterExtensionsOutput) ToSkeClusterExtensionsPtrOutput() SkeClusterExtensionsPtrOutput { + return o.ToSkeClusterExtensionsPtrOutputWithContext(context.Background()) +} + +func (o SkeClusterExtensionsOutput) ToSkeClusterExtensionsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterExtensions) *SkeClusterExtensions { + return &v + }).(SkeClusterExtensionsPtrOutput) +} + +// Cluster access control configuration. +func (o SkeClusterExtensionsOutput) Acl() SkeClusterExtensionsAclPtrOutput { + return o.ApplyT(func(v SkeClusterExtensions) *SkeClusterExtensionsAcl { return v.Acl }).(SkeClusterExtensionsAclPtrOutput) +} + +// A single argus block as defined below. +func (o SkeClusterExtensionsOutput) Argus() SkeClusterExtensionsArgusPtrOutput { + return o.ApplyT(func(v SkeClusterExtensions) *SkeClusterExtensionsArgus { return v.Argus }).(SkeClusterExtensionsArgusPtrOutput) +} + +// DNS extension configuration +func (o SkeClusterExtensionsOutput) Dns() SkeClusterExtensionsDnsPtrOutput { + return o.ApplyT(func(v SkeClusterExtensions) *SkeClusterExtensionsDns { return v.Dns }).(SkeClusterExtensionsDnsPtrOutput) +} + +type SkeClusterExtensionsPtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensions)(nil)).Elem() +} + +func (o SkeClusterExtensionsPtrOutput) ToSkeClusterExtensionsPtrOutput() SkeClusterExtensionsPtrOutput { + return o +} + +func (o SkeClusterExtensionsPtrOutput) ToSkeClusterExtensionsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsPtrOutput { + return o +} + +func (o SkeClusterExtensionsPtrOutput) Elem() SkeClusterExtensionsOutput { + return o.ApplyT(func(v *SkeClusterExtensions) SkeClusterExtensions { + if v != nil { + return *v + } + var ret SkeClusterExtensions + return ret + }).(SkeClusterExtensionsOutput) +} + +// Cluster access control configuration. +func (o SkeClusterExtensionsPtrOutput) Acl() SkeClusterExtensionsAclPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensions) *SkeClusterExtensionsAcl { + if v == nil { + return nil + } + return v.Acl + }).(SkeClusterExtensionsAclPtrOutput) +} + +// A single argus block as defined below. +func (o SkeClusterExtensionsPtrOutput) Argus() SkeClusterExtensionsArgusPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensions) *SkeClusterExtensionsArgus { + if v == nil { + return nil + } + return v.Argus + }).(SkeClusterExtensionsArgusPtrOutput) +} + +// DNS extension configuration +func (o SkeClusterExtensionsPtrOutput) Dns() SkeClusterExtensionsDnsPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensions) *SkeClusterExtensionsDns { + if v == nil { + return nil + } + return v.Dns + }).(SkeClusterExtensionsDnsPtrOutput) +} + +type SkeClusterExtensionsAcl struct { + // Specify a list of CIDRs to whitelist. + AllowedCidrs []string `pulumi:"allowedCidrs"` + // Is ACL enabled? + Enabled bool `pulumi:"enabled"` +} + +// SkeClusterExtensionsAclInput is an input type that accepts SkeClusterExtensionsAclArgs and SkeClusterExtensionsAclOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsAclInput` via: +// +// SkeClusterExtensionsAclArgs{...} +type SkeClusterExtensionsAclInput interface { + pulumi.Input + + ToSkeClusterExtensionsAclOutput() SkeClusterExtensionsAclOutput + ToSkeClusterExtensionsAclOutputWithContext(context.Context) SkeClusterExtensionsAclOutput +} + +type SkeClusterExtensionsAclArgs struct { + // Specify a list of CIDRs to whitelist. + AllowedCidrs pulumi.StringArrayInput `pulumi:"allowedCidrs"` + // Is ACL enabled? + Enabled pulumi.BoolInput `pulumi:"enabled"` +} + +func (SkeClusterExtensionsAclArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsAcl)(nil)).Elem() +} + +func (i SkeClusterExtensionsAclArgs) ToSkeClusterExtensionsAclOutput() SkeClusterExtensionsAclOutput { + return i.ToSkeClusterExtensionsAclOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsAclArgs) ToSkeClusterExtensionsAclOutputWithContext(ctx context.Context) SkeClusterExtensionsAclOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsAclOutput) +} + +func (i SkeClusterExtensionsAclArgs) ToSkeClusterExtensionsAclPtrOutput() SkeClusterExtensionsAclPtrOutput { + return i.ToSkeClusterExtensionsAclPtrOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsAclArgs) ToSkeClusterExtensionsAclPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsAclPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsAclOutput).ToSkeClusterExtensionsAclPtrOutputWithContext(ctx) +} + +// SkeClusterExtensionsAclPtrInput is an input type that accepts SkeClusterExtensionsAclArgs, SkeClusterExtensionsAclPtr and SkeClusterExtensionsAclPtrOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsAclPtrInput` via: +// +// SkeClusterExtensionsAclArgs{...} +// +// or: +// +// nil +type SkeClusterExtensionsAclPtrInput interface { + pulumi.Input + + ToSkeClusterExtensionsAclPtrOutput() SkeClusterExtensionsAclPtrOutput + ToSkeClusterExtensionsAclPtrOutputWithContext(context.Context) SkeClusterExtensionsAclPtrOutput +} + +type skeClusterExtensionsAclPtrType SkeClusterExtensionsAclArgs + +func SkeClusterExtensionsAclPtr(v *SkeClusterExtensionsAclArgs) SkeClusterExtensionsAclPtrInput { + return (*skeClusterExtensionsAclPtrType)(v) +} + +func (*skeClusterExtensionsAclPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsAcl)(nil)).Elem() +} + +func (i *skeClusterExtensionsAclPtrType) ToSkeClusterExtensionsAclPtrOutput() SkeClusterExtensionsAclPtrOutput { + return i.ToSkeClusterExtensionsAclPtrOutputWithContext(context.Background()) +} + +func (i *skeClusterExtensionsAclPtrType) ToSkeClusterExtensionsAclPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsAclPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsAclPtrOutput) +} + +type SkeClusterExtensionsAclOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsAclOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsAcl)(nil)).Elem() +} + +func (o SkeClusterExtensionsAclOutput) ToSkeClusterExtensionsAclOutput() SkeClusterExtensionsAclOutput { + return o +} + +func (o SkeClusterExtensionsAclOutput) ToSkeClusterExtensionsAclOutputWithContext(ctx context.Context) SkeClusterExtensionsAclOutput { + return o +} + +func (o SkeClusterExtensionsAclOutput) ToSkeClusterExtensionsAclPtrOutput() SkeClusterExtensionsAclPtrOutput { + return o.ToSkeClusterExtensionsAclPtrOutputWithContext(context.Background()) +} + +func (o SkeClusterExtensionsAclOutput) ToSkeClusterExtensionsAclPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsAclPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterExtensionsAcl) *SkeClusterExtensionsAcl { + return &v + }).(SkeClusterExtensionsAclPtrOutput) +} + +// Specify a list of CIDRs to whitelist. +func (o SkeClusterExtensionsAclOutput) AllowedCidrs() pulumi.StringArrayOutput { + return o.ApplyT(func(v SkeClusterExtensionsAcl) []string { return v.AllowedCidrs }).(pulumi.StringArrayOutput) +} + +// Is ACL enabled? +func (o SkeClusterExtensionsAclOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v SkeClusterExtensionsAcl) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +type SkeClusterExtensionsAclPtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsAclPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsAcl)(nil)).Elem() +} + +func (o SkeClusterExtensionsAclPtrOutput) ToSkeClusterExtensionsAclPtrOutput() SkeClusterExtensionsAclPtrOutput { + return o +} + +func (o SkeClusterExtensionsAclPtrOutput) ToSkeClusterExtensionsAclPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsAclPtrOutput { + return o +} + +func (o SkeClusterExtensionsAclPtrOutput) Elem() SkeClusterExtensionsAclOutput { + return o.ApplyT(func(v *SkeClusterExtensionsAcl) SkeClusterExtensionsAcl { + if v != nil { + return *v + } + var ret SkeClusterExtensionsAcl + return ret + }).(SkeClusterExtensionsAclOutput) +} + +// Specify a list of CIDRs to whitelist. +func (o SkeClusterExtensionsAclPtrOutput) AllowedCidrs() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SkeClusterExtensionsAcl) []string { + if v == nil { + return nil + } + return v.AllowedCidrs + }).(pulumi.StringArrayOutput) +} + +// Is ACL enabled? +func (o SkeClusterExtensionsAclPtrOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensionsAcl) *bool { + if v == nil { + return nil + } + return &v.Enabled + }).(pulumi.BoolPtrOutput) +} + +type SkeClusterExtensionsArgus struct { + // Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + ArgusInstanceId *string `pulumi:"argusInstanceId"` + // Flag to enable/disable Argus extensions. + Enabled bool `pulumi:"enabled"` +} + +// SkeClusterExtensionsArgusInput is an input type that accepts SkeClusterExtensionsArgusArgs and SkeClusterExtensionsArgusOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsArgusInput` via: +// +// SkeClusterExtensionsArgusArgs{...} +type SkeClusterExtensionsArgusInput interface { + pulumi.Input + + ToSkeClusterExtensionsArgusOutput() SkeClusterExtensionsArgusOutput + ToSkeClusterExtensionsArgusOutputWithContext(context.Context) SkeClusterExtensionsArgusOutput +} + +type SkeClusterExtensionsArgusArgs struct { + // Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + ArgusInstanceId pulumi.StringPtrInput `pulumi:"argusInstanceId"` + // Flag to enable/disable Argus extensions. + Enabled pulumi.BoolInput `pulumi:"enabled"` +} + +func (SkeClusterExtensionsArgusArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsArgus)(nil)).Elem() +} + +func (i SkeClusterExtensionsArgusArgs) ToSkeClusterExtensionsArgusOutput() SkeClusterExtensionsArgusOutput { + return i.ToSkeClusterExtensionsArgusOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsArgusArgs) ToSkeClusterExtensionsArgusOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsArgusOutput) +} + +func (i SkeClusterExtensionsArgusArgs) ToSkeClusterExtensionsArgusPtrOutput() SkeClusterExtensionsArgusPtrOutput { + return i.ToSkeClusterExtensionsArgusPtrOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsArgusArgs) ToSkeClusterExtensionsArgusPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsArgusOutput).ToSkeClusterExtensionsArgusPtrOutputWithContext(ctx) +} + +// SkeClusterExtensionsArgusPtrInput is an input type that accepts SkeClusterExtensionsArgusArgs, SkeClusterExtensionsArgusPtr and SkeClusterExtensionsArgusPtrOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsArgusPtrInput` via: +// +// SkeClusterExtensionsArgusArgs{...} +// +// or: +// +// nil +type SkeClusterExtensionsArgusPtrInput interface { + pulumi.Input + + ToSkeClusterExtensionsArgusPtrOutput() SkeClusterExtensionsArgusPtrOutput + ToSkeClusterExtensionsArgusPtrOutputWithContext(context.Context) SkeClusterExtensionsArgusPtrOutput +} + +type skeClusterExtensionsArgusPtrType SkeClusterExtensionsArgusArgs + +func SkeClusterExtensionsArgusPtr(v *SkeClusterExtensionsArgusArgs) SkeClusterExtensionsArgusPtrInput { + return (*skeClusterExtensionsArgusPtrType)(v) +} + +func (*skeClusterExtensionsArgusPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsArgus)(nil)).Elem() +} + +func (i *skeClusterExtensionsArgusPtrType) ToSkeClusterExtensionsArgusPtrOutput() SkeClusterExtensionsArgusPtrOutput { + return i.ToSkeClusterExtensionsArgusPtrOutputWithContext(context.Background()) +} + +func (i *skeClusterExtensionsArgusPtrType) ToSkeClusterExtensionsArgusPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsArgusPtrOutput) +} + +type SkeClusterExtensionsArgusOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsArgusOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsArgus)(nil)).Elem() +} + +func (o SkeClusterExtensionsArgusOutput) ToSkeClusterExtensionsArgusOutput() SkeClusterExtensionsArgusOutput { + return o +} + +func (o SkeClusterExtensionsArgusOutput) ToSkeClusterExtensionsArgusOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusOutput { + return o +} + +func (o SkeClusterExtensionsArgusOutput) ToSkeClusterExtensionsArgusPtrOutput() SkeClusterExtensionsArgusPtrOutput { + return o.ToSkeClusterExtensionsArgusPtrOutputWithContext(context.Background()) +} + +func (o SkeClusterExtensionsArgusOutput) ToSkeClusterExtensionsArgusPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterExtensionsArgus) *SkeClusterExtensionsArgus { + return &v + }).(SkeClusterExtensionsArgusPtrOutput) +} + +// Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. +func (o SkeClusterExtensionsArgusOutput) ArgusInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterExtensionsArgus) *string { return v.ArgusInstanceId }).(pulumi.StringPtrOutput) +} + +// Flag to enable/disable Argus extensions. +func (o SkeClusterExtensionsArgusOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v SkeClusterExtensionsArgus) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +type SkeClusterExtensionsArgusPtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsArgusPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsArgus)(nil)).Elem() +} + +func (o SkeClusterExtensionsArgusPtrOutput) ToSkeClusterExtensionsArgusPtrOutput() SkeClusterExtensionsArgusPtrOutput { + return o +} + +func (o SkeClusterExtensionsArgusPtrOutput) ToSkeClusterExtensionsArgusPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsArgusPtrOutput { + return o +} + +func (o SkeClusterExtensionsArgusPtrOutput) Elem() SkeClusterExtensionsArgusOutput { + return o.ApplyT(func(v *SkeClusterExtensionsArgus) SkeClusterExtensionsArgus { + if v != nil { + return *v + } + var ret SkeClusterExtensionsArgus + return ret + }).(SkeClusterExtensionsArgusOutput) +} + +// Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. +func (o SkeClusterExtensionsArgusPtrOutput) ArgusInstanceId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensionsArgus) *string { + if v == nil { + return nil + } + return v.ArgusInstanceId + }).(pulumi.StringPtrOutput) +} + +// Flag to enable/disable Argus extensions. +func (o SkeClusterExtensionsArgusPtrOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensionsArgus) *bool { + if v == nil { + return nil + } + return &v.Enabled + }).(pulumi.BoolPtrOutput) +} + +type SkeClusterExtensionsDns struct { + // Flag to enable/disable DNS extensions + Enabled bool `pulumi:"enabled"` + // Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + Zones []string `pulumi:"zones"` +} + +// SkeClusterExtensionsDnsInput is an input type that accepts SkeClusterExtensionsDnsArgs and SkeClusterExtensionsDnsOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsDnsInput` via: +// +// SkeClusterExtensionsDnsArgs{...} +type SkeClusterExtensionsDnsInput interface { + pulumi.Input + + ToSkeClusterExtensionsDnsOutput() SkeClusterExtensionsDnsOutput + ToSkeClusterExtensionsDnsOutputWithContext(context.Context) SkeClusterExtensionsDnsOutput +} + +type SkeClusterExtensionsDnsArgs struct { + // Flag to enable/disable DNS extensions + Enabled pulumi.BoolInput `pulumi:"enabled"` + // Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + Zones pulumi.StringArrayInput `pulumi:"zones"` +} + +func (SkeClusterExtensionsDnsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsDns)(nil)).Elem() +} + +func (i SkeClusterExtensionsDnsArgs) ToSkeClusterExtensionsDnsOutput() SkeClusterExtensionsDnsOutput { + return i.ToSkeClusterExtensionsDnsOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsDnsArgs) ToSkeClusterExtensionsDnsOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsDnsOutput) +} + +func (i SkeClusterExtensionsDnsArgs) ToSkeClusterExtensionsDnsPtrOutput() SkeClusterExtensionsDnsPtrOutput { + return i.ToSkeClusterExtensionsDnsPtrOutputWithContext(context.Background()) +} + +func (i SkeClusterExtensionsDnsArgs) ToSkeClusterExtensionsDnsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsDnsOutput).ToSkeClusterExtensionsDnsPtrOutputWithContext(ctx) +} + +// SkeClusterExtensionsDnsPtrInput is an input type that accepts SkeClusterExtensionsDnsArgs, SkeClusterExtensionsDnsPtr and SkeClusterExtensionsDnsPtrOutput values. +// You can construct a concrete instance of `SkeClusterExtensionsDnsPtrInput` via: +// +// SkeClusterExtensionsDnsArgs{...} +// +// or: +// +// nil +type SkeClusterExtensionsDnsPtrInput interface { + pulumi.Input + + ToSkeClusterExtensionsDnsPtrOutput() SkeClusterExtensionsDnsPtrOutput + ToSkeClusterExtensionsDnsPtrOutputWithContext(context.Context) SkeClusterExtensionsDnsPtrOutput +} + +type skeClusterExtensionsDnsPtrType SkeClusterExtensionsDnsArgs + +func SkeClusterExtensionsDnsPtr(v *SkeClusterExtensionsDnsArgs) SkeClusterExtensionsDnsPtrInput { + return (*skeClusterExtensionsDnsPtrType)(v) +} + +func (*skeClusterExtensionsDnsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsDns)(nil)).Elem() +} + +func (i *skeClusterExtensionsDnsPtrType) ToSkeClusterExtensionsDnsPtrOutput() SkeClusterExtensionsDnsPtrOutput { + return i.ToSkeClusterExtensionsDnsPtrOutputWithContext(context.Background()) +} + +func (i *skeClusterExtensionsDnsPtrType) ToSkeClusterExtensionsDnsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterExtensionsDnsPtrOutput) +} + +type SkeClusterExtensionsDnsOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsDnsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterExtensionsDns)(nil)).Elem() +} + +func (o SkeClusterExtensionsDnsOutput) ToSkeClusterExtensionsDnsOutput() SkeClusterExtensionsDnsOutput { + return o +} + +func (o SkeClusterExtensionsDnsOutput) ToSkeClusterExtensionsDnsOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsOutput { + return o +} + +func (o SkeClusterExtensionsDnsOutput) ToSkeClusterExtensionsDnsPtrOutput() SkeClusterExtensionsDnsPtrOutput { + return o.ToSkeClusterExtensionsDnsPtrOutputWithContext(context.Background()) +} + +func (o SkeClusterExtensionsDnsOutput) ToSkeClusterExtensionsDnsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterExtensionsDns) *SkeClusterExtensionsDns { + return &v + }).(SkeClusterExtensionsDnsPtrOutput) +} + +// Flag to enable/disable DNS extensions +func (o SkeClusterExtensionsDnsOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v SkeClusterExtensionsDns) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) +func (o SkeClusterExtensionsDnsOutput) Zones() pulumi.StringArrayOutput { + return o.ApplyT(func(v SkeClusterExtensionsDns) []string { return v.Zones }).(pulumi.StringArrayOutput) +} + +type SkeClusterExtensionsDnsPtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterExtensionsDnsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterExtensionsDns)(nil)).Elem() +} + +func (o SkeClusterExtensionsDnsPtrOutput) ToSkeClusterExtensionsDnsPtrOutput() SkeClusterExtensionsDnsPtrOutput { + return o +} + +func (o SkeClusterExtensionsDnsPtrOutput) ToSkeClusterExtensionsDnsPtrOutputWithContext(ctx context.Context) SkeClusterExtensionsDnsPtrOutput { + return o +} + +func (o SkeClusterExtensionsDnsPtrOutput) Elem() SkeClusterExtensionsDnsOutput { + return o.ApplyT(func(v *SkeClusterExtensionsDns) SkeClusterExtensionsDns { + if v != nil { + return *v + } + var ret SkeClusterExtensionsDns + return ret + }).(SkeClusterExtensionsDnsOutput) +} + +// Flag to enable/disable DNS extensions +func (o SkeClusterExtensionsDnsPtrOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeClusterExtensionsDns) *bool { + if v == nil { + return nil + } + return &v.Enabled + }).(pulumi.BoolPtrOutput) +} + +// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) +func (o SkeClusterExtensionsDnsPtrOutput) Zones() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SkeClusterExtensionsDns) []string { + if v == nil { + return nil + } + return v.Zones + }).(pulumi.StringArrayOutput) +} + +type SkeClusterHibernation struct { + // End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + End string `pulumi:"end"` + // Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + Start string `pulumi:"start"` + // Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + Timezone *string `pulumi:"timezone"` +} + +// SkeClusterHibernationInput is an input type that accepts SkeClusterHibernationArgs and SkeClusterHibernationOutput values. +// You can construct a concrete instance of `SkeClusterHibernationInput` via: +// +// SkeClusterHibernationArgs{...} +type SkeClusterHibernationInput interface { + pulumi.Input + + ToSkeClusterHibernationOutput() SkeClusterHibernationOutput + ToSkeClusterHibernationOutputWithContext(context.Context) SkeClusterHibernationOutput +} + +type SkeClusterHibernationArgs struct { + // End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + End pulumi.StringInput `pulumi:"end"` + // Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + Start pulumi.StringInput `pulumi:"start"` + // Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + Timezone pulumi.StringPtrInput `pulumi:"timezone"` +} + +func (SkeClusterHibernationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterHibernation)(nil)).Elem() +} + +func (i SkeClusterHibernationArgs) ToSkeClusterHibernationOutput() SkeClusterHibernationOutput { + return i.ToSkeClusterHibernationOutputWithContext(context.Background()) +} + +func (i SkeClusterHibernationArgs) ToSkeClusterHibernationOutputWithContext(ctx context.Context) SkeClusterHibernationOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterHibernationOutput) +} + +// SkeClusterHibernationArrayInput is an input type that accepts SkeClusterHibernationArray and SkeClusterHibernationArrayOutput values. +// You can construct a concrete instance of `SkeClusterHibernationArrayInput` via: +// +// SkeClusterHibernationArray{ SkeClusterHibernationArgs{...} } +type SkeClusterHibernationArrayInput interface { + pulumi.Input + + ToSkeClusterHibernationArrayOutput() SkeClusterHibernationArrayOutput + ToSkeClusterHibernationArrayOutputWithContext(context.Context) SkeClusterHibernationArrayOutput +} + +type SkeClusterHibernationArray []SkeClusterHibernationInput + +func (SkeClusterHibernationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterHibernation)(nil)).Elem() +} + +func (i SkeClusterHibernationArray) ToSkeClusterHibernationArrayOutput() SkeClusterHibernationArrayOutput { + return i.ToSkeClusterHibernationArrayOutputWithContext(context.Background()) +} + +func (i SkeClusterHibernationArray) ToSkeClusterHibernationArrayOutputWithContext(ctx context.Context) SkeClusterHibernationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterHibernationArrayOutput) +} + +type SkeClusterHibernationOutput struct{ *pulumi.OutputState } + +func (SkeClusterHibernationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterHibernation)(nil)).Elem() +} + +func (o SkeClusterHibernationOutput) ToSkeClusterHibernationOutput() SkeClusterHibernationOutput { + return o +} + +func (o SkeClusterHibernationOutput) ToSkeClusterHibernationOutputWithContext(ctx context.Context) SkeClusterHibernationOutput { + return o +} + +// End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. +func (o SkeClusterHibernationOutput) End() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterHibernation) string { return v.End }).(pulumi.StringOutput) +} + +// Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. +func (o SkeClusterHibernationOutput) Start() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterHibernation) string { return v.Start }).(pulumi.StringOutput) +} + +// Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. +func (o SkeClusterHibernationOutput) Timezone() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterHibernation) *string { return v.Timezone }).(pulumi.StringPtrOutput) +} + +type SkeClusterHibernationArrayOutput struct{ *pulumi.OutputState } + +func (SkeClusterHibernationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterHibernation)(nil)).Elem() +} + +func (o SkeClusterHibernationArrayOutput) ToSkeClusterHibernationArrayOutput() SkeClusterHibernationArrayOutput { + return o +} + +func (o SkeClusterHibernationArrayOutput) ToSkeClusterHibernationArrayOutputWithContext(ctx context.Context) SkeClusterHibernationArrayOutput { + return o +} + +func (o SkeClusterHibernationArrayOutput) Index(i pulumi.IntInput) SkeClusterHibernationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) SkeClusterHibernation { + return vs[0].([]SkeClusterHibernation)[vs[1].(int)] + }).(SkeClusterHibernationOutput) +} + +type SkeClusterMaintenance struct { + // Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + EnableKubernetesVersionUpdates *bool `pulumi:"enableKubernetesVersionUpdates"` + // Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + EnableMachineImageVersionUpdates *bool `pulumi:"enableMachineImageVersionUpdates"` + // Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + End string `pulumi:"end"` + // Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + Start string `pulumi:"start"` +} + +// SkeClusterMaintenanceInput is an input type that accepts SkeClusterMaintenanceArgs and SkeClusterMaintenanceOutput values. +// You can construct a concrete instance of `SkeClusterMaintenanceInput` via: +// +// SkeClusterMaintenanceArgs{...} +type SkeClusterMaintenanceInput interface { + pulumi.Input + + ToSkeClusterMaintenanceOutput() SkeClusterMaintenanceOutput + ToSkeClusterMaintenanceOutputWithContext(context.Context) SkeClusterMaintenanceOutput +} + +type SkeClusterMaintenanceArgs struct { + // Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + EnableKubernetesVersionUpdates pulumi.BoolPtrInput `pulumi:"enableKubernetesVersionUpdates"` + // Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + EnableMachineImageVersionUpdates pulumi.BoolPtrInput `pulumi:"enableMachineImageVersionUpdates"` + // Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + End pulumi.StringInput `pulumi:"end"` + // Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + Start pulumi.StringInput `pulumi:"start"` +} + +func (SkeClusterMaintenanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterMaintenance)(nil)).Elem() +} + +func (i SkeClusterMaintenanceArgs) ToSkeClusterMaintenanceOutput() SkeClusterMaintenanceOutput { + return i.ToSkeClusterMaintenanceOutputWithContext(context.Background()) +} + +func (i SkeClusterMaintenanceArgs) ToSkeClusterMaintenanceOutputWithContext(ctx context.Context) SkeClusterMaintenanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterMaintenanceOutput) +} + +func (i SkeClusterMaintenanceArgs) ToSkeClusterMaintenancePtrOutput() SkeClusterMaintenancePtrOutput { + return i.ToSkeClusterMaintenancePtrOutputWithContext(context.Background()) +} + +func (i SkeClusterMaintenanceArgs) ToSkeClusterMaintenancePtrOutputWithContext(ctx context.Context) SkeClusterMaintenancePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterMaintenanceOutput).ToSkeClusterMaintenancePtrOutputWithContext(ctx) +} + +// SkeClusterMaintenancePtrInput is an input type that accepts SkeClusterMaintenanceArgs, SkeClusterMaintenancePtr and SkeClusterMaintenancePtrOutput values. +// You can construct a concrete instance of `SkeClusterMaintenancePtrInput` via: +// +// SkeClusterMaintenanceArgs{...} +// +// or: +// +// nil +type SkeClusterMaintenancePtrInput interface { + pulumi.Input + + ToSkeClusterMaintenancePtrOutput() SkeClusterMaintenancePtrOutput + ToSkeClusterMaintenancePtrOutputWithContext(context.Context) SkeClusterMaintenancePtrOutput +} + +type skeClusterMaintenancePtrType SkeClusterMaintenanceArgs + +func SkeClusterMaintenancePtr(v *SkeClusterMaintenanceArgs) SkeClusterMaintenancePtrInput { + return (*skeClusterMaintenancePtrType)(v) +} + +func (*skeClusterMaintenancePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterMaintenance)(nil)).Elem() +} + +func (i *skeClusterMaintenancePtrType) ToSkeClusterMaintenancePtrOutput() SkeClusterMaintenancePtrOutput { + return i.ToSkeClusterMaintenancePtrOutputWithContext(context.Background()) +} + +func (i *skeClusterMaintenancePtrType) ToSkeClusterMaintenancePtrOutputWithContext(ctx context.Context) SkeClusterMaintenancePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterMaintenancePtrOutput) +} + +type SkeClusterMaintenanceOutput struct{ *pulumi.OutputState } + +func (SkeClusterMaintenanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterMaintenance)(nil)).Elem() +} + +func (o SkeClusterMaintenanceOutput) ToSkeClusterMaintenanceOutput() SkeClusterMaintenanceOutput { + return o +} + +func (o SkeClusterMaintenanceOutput) ToSkeClusterMaintenanceOutputWithContext(ctx context.Context) SkeClusterMaintenanceOutput { + return o +} + +func (o SkeClusterMaintenanceOutput) ToSkeClusterMaintenancePtrOutput() SkeClusterMaintenancePtrOutput { + return o.ToSkeClusterMaintenancePtrOutputWithContext(context.Background()) +} + +func (o SkeClusterMaintenanceOutput) ToSkeClusterMaintenancePtrOutputWithContext(ctx context.Context) SkeClusterMaintenancePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterMaintenance) *SkeClusterMaintenance { + return &v + }).(SkeClusterMaintenancePtrOutput) +} + +// Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterMaintenanceOutput) EnableKubernetesVersionUpdates() pulumi.BoolPtrOutput { + return o.ApplyT(func(v SkeClusterMaintenance) *bool { return v.EnableKubernetesVersionUpdates }).(pulumi.BoolPtrOutput) +} + +// Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterMaintenanceOutput) EnableMachineImageVersionUpdates() pulumi.BoolPtrOutput { + return o.ApplyT(func(v SkeClusterMaintenance) *bool { return v.EnableMachineImageVersionUpdates }).(pulumi.BoolPtrOutput) +} + +// Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. +func (o SkeClusterMaintenanceOutput) End() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterMaintenance) string { return v.End }).(pulumi.StringOutput) +} + +// Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. +func (o SkeClusterMaintenanceOutput) Start() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterMaintenance) string { return v.Start }).(pulumi.StringOutput) +} + +type SkeClusterMaintenancePtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterMaintenancePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterMaintenance)(nil)).Elem() +} + +func (o SkeClusterMaintenancePtrOutput) ToSkeClusterMaintenancePtrOutput() SkeClusterMaintenancePtrOutput { + return o +} + +func (o SkeClusterMaintenancePtrOutput) ToSkeClusterMaintenancePtrOutputWithContext(ctx context.Context) SkeClusterMaintenancePtrOutput { + return o +} + +func (o SkeClusterMaintenancePtrOutput) Elem() SkeClusterMaintenanceOutput { + return o.ApplyT(func(v *SkeClusterMaintenance) SkeClusterMaintenance { + if v != nil { + return *v + } + var ret SkeClusterMaintenance + return ret + }).(SkeClusterMaintenanceOutput) +} + +// Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterMaintenancePtrOutput) EnableKubernetesVersionUpdates() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeClusterMaintenance) *bool { + if v == nil { + return nil + } + return v.EnableKubernetesVersionUpdates + }).(pulumi.BoolPtrOutput) +} + +// Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterMaintenancePtrOutput) EnableMachineImageVersionUpdates() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeClusterMaintenance) *bool { + if v == nil { + return nil + } + return v.EnableMachineImageVersionUpdates + }).(pulumi.BoolPtrOutput) +} + +// Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. +func (o SkeClusterMaintenancePtrOutput) End() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeClusterMaintenance) *string { + if v == nil { + return nil + } + return &v.End + }).(pulumi.StringPtrOutput) +} + +// Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. +func (o SkeClusterMaintenancePtrOutput) Start() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeClusterMaintenance) *string { + if v == nil { + return nil + } + return &v.Start + }).(pulumi.StringPtrOutput) +} + +type SkeClusterNetwork struct { + // ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + Id *string `pulumi:"id"` +} + +// SkeClusterNetworkInput is an input type that accepts SkeClusterNetworkArgs and SkeClusterNetworkOutput values. +// You can construct a concrete instance of `SkeClusterNetworkInput` via: +// +// SkeClusterNetworkArgs{...} +type SkeClusterNetworkInput interface { + pulumi.Input + + ToSkeClusterNetworkOutput() SkeClusterNetworkOutput + ToSkeClusterNetworkOutputWithContext(context.Context) SkeClusterNetworkOutput +} + +type SkeClusterNetworkArgs struct { + // ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + Id pulumi.StringPtrInput `pulumi:"id"` +} + +func (SkeClusterNetworkArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNetwork)(nil)).Elem() +} + +func (i SkeClusterNetworkArgs) ToSkeClusterNetworkOutput() SkeClusterNetworkOutput { + return i.ToSkeClusterNetworkOutputWithContext(context.Background()) +} + +func (i SkeClusterNetworkArgs) ToSkeClusterNetworkOutputWithContext(ctx context.Context) SkeClusterNetworkOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNetworkOutput) +} + +func (i SkeClusterNetworkArgs) ToSkeClusterNetworkPtrOutput() SkeClusterNetworkPtrOutput { + return i.ToSkeClusterNetworkPtrOutputWithContext(context.Background()) +} + +func (i SkeClusterNetworkArgs) ToSkeClusterNetworkPtrOutputWithContext(ctx context.Context) SkeClusterNetworkPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNetworkOutput).ToSkeClusterNetworkPtrOutputWithContext(ctx) +} + +// SkeClusterNetworkPtrInput is an input type that accepts SkeClusterNetworkArgs, SkeClusterNetworkPtr and SkeClusterNetworkPtrOutput values. +// You can construct a concrete instance of `SkeClusterNetworkPtrInput` via: +// +// SkeClusterNetworkArgs{...} +// +// or: +// +// nil +type SkeClusterNetworkPtrInput interface { + pulumi.Input + + ToSkeClusterNetworkPtrOutput() SkeClusterNetworkPtrOutput + ToSkeClusterNetworkPtrOutputWithContext(context.Context) SkeClusterNetworkPtrOutput +} + +type skeClusterNetworkPtrType SkeClusterNetworkArgs + +func SkeClusterNetworkPtr(v *SkeClusterNetworkArgs) SkeClusterNetworkPtrInput { + return (*skeClusterNetworkPtrType)(v) +} + +func (*skeClusterNetworkPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterNetwork)(nil)).Elem() +} + +func (i *skeClusterNetworkPtrType) ToSkeClusterNetworkPtrOutput() SkeClusterNetworkPtrOutput { + return i.ToSkeClusterNetworkPtrOutputWithContext(context.Background()) +} + +func (i *skeClusterNetworkPtrType) ToSkeClusterNetworkPtrOutputWithContext(ctx context.Context) SkeClusterNetworkPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNetworkPtrOutput) +} + +type SkeClusterNetworkOutput struct{ *pulumi.OutputState } + +func (SkeClusterNetworkOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNetwork)(nil)).Elem() +} + +func (o SkeClusterNetworkOutput) ToSkeClusterNetworkOutput() SkeClusterNetworkOutput { + return o +} + +func (o SkeClusterNetworkOutput) ToSkeClusterNetworkOutputWithContext(ctx context.Context) SkeClusterNetworkOutput { + return o +} + +func (o SkeClusterNetworkOutput) ToSkeClusterNetworkPtrOutput() SkeClusterNetworkPtrOutput { + return o.ToSkeClusterNetworkPtrOutputWithContext(context.Background()) +} + +func (o SkeClusterNetworkOutput) ToSkeClusterNetworkPtrOutputWithContext(ctx context.Context) SkeClusterNetworkPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SkeClusterNetwork) *SkeClusterNetwork { + return &v + }).(SkeClusterNetworkPtrOutput) +} + +// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. +func (o SkeClusterNetworkOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNetwork) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +type SkeClusterNetworkPtrOutput struct{ *pulumi.OutputState } + +func (SkeClusterNetworkPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeClusterNetwork)(nil)).Elem() +} + +func (o SkeClusterNetworkPtrOutput) ToSkeClusterNetworkPtrOutput() SkeClusterNetworkPtrOutput { + return o +} + +func (o SkeClusterNetworkPtrOutput) ToSkeClusterNetworkPtrOutputWithContext(ctx context.Context) SkeClusterNetworkPtrOutput { + return o +} + +func (o SkeClusterNetworkPtrOutput) Elem() SkeClusterNetworkOutput { + return o.ApplyT(func(v *SkeClusterNetwork) SkeClusterNetwork { + if v != nil { + return *v + } + var ret SkeClusterNetwork + return ret + }).(SkeClusterNetworkOutput) +} + +// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. +func (o SkeClusterNetworkPtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeClusterNetwork) *string { + if v == nil { + return nil + } + return v.Id + }).(pulumi.StringPtrOutput) +} + +type SkeClusterNodePool struct { + // Allow system components to run on this node pool. + AllowSystemComponents *bool `pulumi:"allowSystemComponents"` + // Specify a list of availability zones. E.g. `eu01-m` + AvailabilityZones []string `pulumi:"availabilityZones"` + // Specifies the container runtime. Defaults to `containerd` + Cri *string `pulumi:"cri"` + // Labels to add to each node. + Labels map[string]string `pulumi:"labels"` + // The machine type. + MachineType string `pulumi:"machineType"` + // Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + MaxSurge *int `pulumi:"maxSurge"` + // Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + MaxUnavailable *int `pulumi:"maxUnavailable"` + // Maximum number of nodes in the pool. + Maximum int `pulumi:"maximum"` + // Minimum number of nodes in the pool. + Minimum int `pulumi:"minimum"` + // Specifies the name of the node pool. + Name string `pulumi:"name"` + // The name of the OS image. Defaults to `flatcar`. + OsName *string `pulumi:"osName"` + // This field is deprecated, use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. + // + // Deprecated: Use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates. + OsVersion *string `pulumi:"osVersion"` + // The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + OsVersionMin *string `pulumi:"osVersionMin"` + // Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + OsVersionUsed *string `pulumi:"osVersionUsed"` + // Specifies a taint list as defined below. + Taints []SkeClusterNodePoolTaint `pulumi:"taints"` + // The volume size in GB. Defaults to `20` + VolumeSize *int `pulumi:"volumeSize"` + // Specifies the volume type. Defaults to `storagePremiumPerf1`. + VolumeType *string `pulumi:"volumeType"` +} + +// SkeClusterNodePoolInput is an input type that accepts SkeClusterNodePoolArgs and SkeClusterNodePoolOutput values. +// You can construct a concrete instance of `SkeClusterNodePoolInput` via: +// +// SkeClusterNodePoolArgs{...} +type SkeClusterNodePoolInput interface { + pulumi.Input + + ToSkeClusterNodePoolOutput() SkeClusterNodePoolOutput + ToSkeClusterNodePoolOutputWithContext(context.Context) SkeClusterNodePoolOutput +} + +type SkeClusterNodePoolArgs struct { + // Allow system components to run on this node pool. + AllowSystemComponents pulumi.BoolPtrInput `pulumi:"allowSystemComponents"` + // Specify a list of availability zones. E.g. `eu01-m` + AvailabilityZones pulumi.StringArrayInput `pulumi:"availabilityZones"` + // Specifies the container runtime. Defaults to `containerd` + Cri pulumi.StringPtrInput `pulumi:"cri"` + // Labels to add to each node. + Labels pulumi.StringMapInput `pulumi:"labels"` + // The machine type. + MachineType pulumi.StringInput `pulumi:"machineType"` + // Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + MaxSurge pulumi.IntPtrInput `pulumi:"maxSurge"` + // Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + MaxUnavailable pulumi.IntPtrInput `pulumi:"maxUnavailable"` + // Maximum number of nodes in the pool. + Maximum pulumi.IntInput `pulumi:"maximum"` + // Minimum number of nodes in the pool. + Minimum pulumi.IntInput `pulumi:"minimum"` + // Specifies the name of the node pool. + Name pulumi.StringInput `pulumi:"name"` + // The name of the OS image. Defaults to `flatcar`. + OsName pulumi.StringPtrInput `pulumi:"osName"` + // This field is deprecated, use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. + // + // Deprecated: Use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates. + OsVersion pulumi.StringPtrInput `pulumi:"osVersion"` + // The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + OsVersionMin pulumi.StringPtrInput `pulumi:"osVersionMin"` + // Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + OsVersionUsed pulumi.StringPtrInput `pulumi:"osVersionUsed"` + // Specifies a taint list as defined below. + Taints SkeClusterNodePoolTaintArrayInput `pulumi:"taints"` + // The volume size in GB. Defaults to `20` + VolumeSize pulumi.IntPtrInput `pulumi:"volumeSize"` + // Specifies the volume type. Defaults to `storagePremiumPerf1`. + VolumeType pulumi.StringPtrInput `pulumi:"volumeType"` +} + +func (SkeClusterNodePoolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNodePool)(nil)).Elem() +} + +func (i SkeClusterNodePoolArgs) ToSkeClusterNodePoolOutput() SkeClusterNodePoolOutput { + return i.ToSkeClusterNodePoolOutputWithContext(context.Background()) +} + +func (i SkeClusterNodePoolArgs) ToSkeClusterNodePoolOutputWithContext(ctx context.Context) SkeClusterNodePoolOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNodePoolOutput) +} + +// SkeClusterNodePoolArrayInput is an input type that accepts SkeClusterNodePoolArray and SkeClusterNodePoolArrayOutput values. +// You can construct a concrete instance of `SkeClusterNodePoolArrayInput` via: +// +// SkeClusterNodePoolArray{ SkeClusterNodePoolArgs{...} } +type SkeClusterNodePoolArrayInput interface { + pulumi.Input + + ToSkeClusterNodePoolArrayOutput() SkeClusterNodePoolArrayOutput + ToSkeClusterNodePoolArrayOutputWithContext(context.Context) SkeClusterNodePoolArrayOutput +} + +type SkeClusterNodePoolArray []SkeClusterNodePoolInput + +func (SkeClusterNodePoolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterNodePool)(nil)).Elem() +} + +func (i SkeClusterNodePoolArray) ToSkeClusterNodePoolArrayOutput() SkeClusterNodePoolArrayOutput { + return i.ToSkeClusterNodePoolArrayOutputWithContext(context.Background()) +} + +func (i SkeClusterNodePoolArray) ToSkeClusterNodePoolArrayOutputWithContext(ctx context.Context) SkeClusterNodePoolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNodePoolArrayOutput) +} + +type SkeClusterNodePoolOutput struct{ *pulumi.OutputState } + +func (SkeClusterNodePoolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNodePool)(nil)).Elem() +} + +func (o SkeClusterNodePoolOutput) ToSkeClusterNodePoolOutput() SkeClusterNodePoolOutput { + return o +} + +func (o SkeClusterNodePoolOutput) ToSkeClusterNodePoolOutputWithContext(ctx context.Context) SkeClusterNodePoolOutput { + return o +} + +// Allow system components to run on this node pool. +func (o SkeClusterNodePoolOutput) AllowSystemComponents() pulumi.BoolPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *bool { return v.AllowSystemComponents }).(pulumi.BoolPtrOutput) +} + +// Specify a list of availability zones. E.g. `eu01-m` +func (o SkeClusterNodePoolOutput) AvailabilityZones() pulumi.StringArrayOutput { + return o.ApplyT(func(v SkeClusterNodePool) []string { return v.AvailabilityZones }).(pulumi.StringArrayOutput) +} + +// Specifies the container runtime. Defaults to `containerd` +func (o SkeClusterNodePoolOutput) Cri() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.Cri }).(pulumi.StringPtrOutput) +} + +// Labels to add to each node. +func (o SkeClusterNodePoolOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v SkeClusterNodePool) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The machine type. +func (o SkeClusterNodePoolOutput) MachineType() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterNodePool) string { return v.MachineType }).(pulumi.StringOutput) +} + +// Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. +func (o SkeClusterNodePoolOutput) MaxSurge() pulumi.IntPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *int { return v.MaxSurge }).(pulumi.IntPtrOutput) +} + +// Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. +func (o SkeClusterNodePoolOutput) MaxUnavailable() pulumi.IntPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *int { return v.MaxUnavailable }).(pulumi.IntPtrOutput) +} + +// Maximum number of nodes in the pool. +func (o SkeClusterNodePoolOutput) Maximum() pulumi.IntOutput { + return o.ApplyT(func(v SkeClusterNodePool) int { return v.Maximum }).(pulumi.IntOutput) +} + +// Minimum number of nodes in the pool. +func (o SkeClusterNodePoolOutput) Minimum() pulumi.IntOutput { + return o.ApplyT(func(v SkeClusterNodePool) int { return v.Minimum }).(pulumi.IntOutput) +} + +// Specifies the name of the node pool. +func (o SkeClusterNodePoolOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterNodePool) string { return v.Name }).(pulumi.StringOutput) +} + +// The name of the OS image. Defaults to `flatcar`. +func (o SkeClusterNodePoolOutput) OsName() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.OsName }).(pulumi.StringPtrOutput) +} + +// This field is deprecated, use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. +// +// Deprecated: Use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates. +func (o SkeClusterNodePoolOutput) OsVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.OsVersion }).(pulumi.StringPtrOutput) +} + +// The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. +func (o SkeClusterNodePoolOutput) OsVersionMin() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.OsVersionMin }).(pulumi.StringPtrOutput) +} + +// Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterNodePoolOutput) OsVersionUsed() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.OsVersionUsed }).(pulumi.StringPtrOutput) +} + +// Specifies a taint list as defined below. +func (o SkeClusterNodePoolOutput) Taints() SkeClusterNodePoolTaintArrayOutput { + return o.ApplyT(func(v SkeClusterNodePool) []SkeClusterNodePoolTaint { return v.Taints }).(SkeClusterNodePoolTaintArrayOutput) +} + +// The volume size in GB. Defaults to `20` +func (o SkeClusterNodePoolOutput) VolumeSize() pulumi.IntPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *int { return v.VolumeSize }).(pulumi.IntPtrOutput) +} + +// Specifies the volume type. Defaults to `storagePremiumPerf1`. +func (o SkeClusterNodePoolOutput) VolumeType() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePool) *string { return v.VolumeType }).(pulumi.StringPtrOutput) +} + +type SkeClusterNodePoolArrayOutput struct{ *pulumi.OutputState } + +func (SkeClusterNodePoolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterNodePool)(nil)).Elem() +} + +func (o SkeClusterNodePoolArrayOutput) ToSkeClusterNodePoolArrayOutput() SkeClusterNodePoolArrayOutput { + return o +} + +func (o SkeClusterNodePoolArrayOutput) ToSkeClusterNodePoolArrayOutputWithContext(ctx context.Context) SkeClusterNodePoolArrayOutput { + return o +} + +func (o SkeClusterNodePoolArrayOutput) Index(i pulumi.IntInput) SkeClusterNodePoolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) SkeClusterNodePool { + return vs[0].([]SkeClusterNodePool)[vs[1].(int)] + }).(SkeClusterNodePoolOutput) +} + +type SkeClusterNodePoolTaint struct { + // The taint effect. E.g `PreferNoSchedule`. + Effect string `pulumi:"effect"` + // Taint key to be applied to a node. + Key string `pulumi:"key"` + // Taint value corresponding to the taint key. + Value *string `pulumi:"value"` +} + +// SkeClusterNodePoolTaintInput is an input type that accepts SkeClusterNodePoolTaintArgs and SkeClusterNodePoolTaintOutput values. +// You can construct a concrete instance of `SkeClusterNodePoolTaintInput` via: +// +// SkeClusterNodePoolTaintArgs{...} +type SkeClusterNodePoolTaintInput interface { + pulumi.Input + + ToSkeClusterNodePoolTaintOutput() SkeClusterNodePoolTaintOutput + ToSkeClusterNodePoolTaintOutputWithContext(context.Context) SkeClusterNodePoolTaintOutput +} + +type SkeClusterNodePoolTaintArgs struct { + // The taint effect. E.g `PreferNoSchedule`. + Effect pulumi.StringInput `pulumi:"effect"` + // Taint key to be applied to a node. + Key pulumi.StringInput `pulumi:"key"` + // Taint value corresponding to the taint key. + Value pulumi.StringPtrInput `pulumi:"value"` +} + +func (SkeClusterNodePoolTaintArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNodePoolTaint)(nil)).Elem() +} + +func (i SkeClusterNodePoolTaintArgs) ToSkeClusterNodePoolTaintOutput() SkeClusterNodePoolTaintOutput { + return i.ToSkeClusterNodePoolTaintOutputWithContext(context.Background()) +} + +func (i SkeClusterNodePoolTaintArgs) ToSkeClusterNodePoolTaintOutputWithContext(ctx context.Context) SkeClusterNodePoolTaintOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNodePoolTaintOutput) +} + +// SkeClusterNodePoolTaintArrayInput is an input type that accepts SkeClusterNodePoolTaintArray and SkeClusterNodePoolTaintArrayOutput values. +// You can construct a concrete instance of `SkeClusterNodePoolTaintArrayInput` via: +// +// SkeClusterNodePoolTaintArray{ SkeClusterNodePoolTaintArgs{...} } +type SkeClusterNodePoolTaintArrayInput interface { + pulumi.Input + + ToSkeClusterNodePoolTaintArrayOutput() SkeClusterNodePoolTaintArrayOutput + ToSkeClusterNodePoolTaintArrayOutputWithContext(context.Context) SkeClusterNodePoolTaintArrayOutput +} + +type SkeClusterNodePoolTaintArray []SkeClusterNodePoolTaintInput + +func (SkeClusterNodePoolTaintArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterNodePoolTaint)(nil)).Elem() +} + +func (i SkeClusterNodePoolTaintArray) ToSkeClusterNodePoolTaintArrayOutput() SkeClusterNodePoolTaintArrayOutput { + return i.ToSkeClusterNodePoolTaintArrayOutputWithContext(context.Background()) +} + +func (i SkeClusterNodePoolTaintArray) ToSkeClusterNodePoolTaintArrayOutputWithContext(ctx context.Context) SkeClusterNodePoolTaintArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterNodePoolTaintArrayOutput) +} + +type SkeClusterNodePoolTaintOutput struct{ *pulumi.OutputState } + +func (SkeClusterNodePoolTaintOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SkeClusterNodePoolTaint)(nil)).Elem() +} + +func (o SkeClusterNodePoolTaintOutput) ToSkeClusterNodePoolTaintOutput() SkeClusterNodePoolTaintOutput { + return o +} + +func (o SkeClusterNodePoolTaintOutput) ToSkeClusterNodePoolTaintOutputWithContext(ctx context.Context) SkeClusterNodePoolTaintOutput { + return o +} + +// The taint effect. E.g `PreferNoSchedule`. +func (o SkeClusterNodePoolTaintOutput) Effect() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterNodePoolTaint) string { return v.Effect }).(pulumi.StringOutput) +} + +// Taint key to be applied to a node. +func (o SkeClusterNodePoolTaintOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v SkeClusterNodePoolTaint) string { return v.Key }).(pulumi.StringOutput) +} + +// Taint value corresponding to the taint key. +func (o SkeClusterNodePoolTaintOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v SkeClusterNodePoolTaint) *string { return v.Value }).(pulumi.StringPtrOutput) +} + +type SkeClusterNodePoolTaintArrayOutput struct{ *pulumi.OutputState } + +func (SkeClusterNodePoolTaintArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]SkeClusterNodePoolTaint)(nil)).Elem() +} + +func (o SkeClusterNodePoolTaintArrayOutput) ToSkeClusterNodePoolTaintArrayOutput() SkeClusterNodePoolTaintArrayOutput { + return o +} + +func (o SkeClusterNodePoolTaintArrayOutput) ToSkeClusterNodePoolTaintArrayOutputWithContext(ctx context.Context) SkeClusterNodePoolTaintArrayOutput { + return o +} + +func (o SkeClusterNodePoolTaintArrayOutput) Index(i pulumi.IntInput) SkeClusterNodePoolTaintOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) SkeClusterNodePoolTaint { + return vs[0].([]SkeClusterNodePoolTaint)[vs[1].(int)] + }).(SkeClusterNodePoolTaintOutput) +} + +type SqlserverflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description *string `pulumi:"description"` + Id *string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// SqlserverflexInstanceFlavorInput is an input type that accepts SqlserverflexInstanceFlavorArgs and SqlserverflexInstanceFlavorOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceFlavorInput` via: +// +// SqlserverflexInstanceFlavorArgs{...} +type SqlserverflexInstanceFlavorInput interface { + pulumi.Input + + ToSqlserverflexInstanceFlavorOutput() SqlserverflexInstanceFlavorOutput + ToSqlserverflexInstanceFlavorOutputWithContext(context.Context) SqlserverflexInstanceFlavorOutput +} + +type SqlserverflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringPtrInput `pulumi:"description"` + Id pulumi.StringPtrInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (SqlserverflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (i SqlserverflexInstanceFlavorArgs) ToSqlserverflexInstanceFlavorOutput() SqlserverflexInstanceFlavorOutput { + return i.ToSqlserverflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceFlavorArgs) ToSqlserverflexInstanceFlavorOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceFlavorOutput) +} + +func (i SqlserverflexInstanceFlavorArgs) ToSqlserverflexInstanceFlavorPtrOutput() SqlserverflexInstanceFlavorPtrOutput { + return i.ToSqlserverflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceFlavorArgs) ToSqlserverflexInstanceFlavorPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceFlavorOutput).ToSqlserverflexInstanceFlavorPtrOutputWithContext(ctx) +} + +// SqlserverflexInstanceFlavorPtrInput is an input type that accepts SqlserverflexInstanceFlavorArgs, SqlserverflexInstanceFlavorPtr and SqlserverflexInstanceFlavorPtrOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceFlavorPtrInput` via: +// +// SqlserverflexInstanceFlavorArgs{...} +// +// or: +// +// nil +type SqlserverflexInstanceFlavorPtrInput interface { + pulumi.Input + + ToSqlserverflexInstanceFlavorPtrOutput() SqlserverflexInstanceFlavorPtrOutput + ToSqlserverflexInstanceFlavorPtrOutputWithContext(context.Context) SqlserverflexInstanceFlavorPtrOutput +} + +type sqlserverflexInstanceFlavorPtrType SqlserverflexInstanceFlavorArgs + +func SqlserverflexInstanceFlavorPtr(v *SqlserverflexInstanceFlavorArgs) SqlserverflexInstanceFlavorPtrInput { + return (*sqlserverflexInstanceFlavorPtrType)(v) +} + +func (*sqlserverflexInstanceFlavorPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (i *sqlserverflexInstanceFlavorPtrType) ToSqlserverflexInstanceFlavorPtrOutput() SqlserverflexInstanceFlavorPtrOutput { + return i.ToSqlserverflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (i *sqlserverflexInstanceFlavorPtrType) ToSqlserverflexInstanceFlavorPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceFlavorPtrOutput) +} + +type SqlserverflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (o SqlserverflexInstanceFlavorOutput) ToSqlserverflexInstanceFlavorOutput() SqlserverflexInstanceFlavorOutput { + return o +} + +func (o SqlserverflexInstanceFlavorOutput) ToSqlserverflexInstanceFlavorOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorOutput { + return o +} + +func (o SqlserverflexInstanceFlavorOutput) ToSqlserverflexInstanceFlavorPtrOutput() SqlserverflexInstanceFlavorPtrOutput { + return o.ToSqlserverflexInstanceFlavorPtrOutputWithContext(context.Background()) +} + +func (o SqlserverflexInstanceFlavorOutput) ToSqlserverflexInstanceFlavorPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SqlserverflexInstanceFlavor) *SqlserverflexInstanceFlavor { + return &v + }).(SqlserverflexInstanceFlavorPtrOutput) +} + +func (o SqlserverflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v SqlserverflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o SqlserverflexInstanceFlavorOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceFlavor) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceFlavorOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceFlavor) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v SqlserverflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type SqlserverflexInstanceFlavorPtrOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceFlavorPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (o SqlserverflexInstanceFlavorPtrOutput) ToSqlserverflexInstanceFlavorPtrOutput() SqlserverflexInstanceFlavorPtrOutput { + return o +} + +func (o SqlserverflexInstanceFlavorPtrOutput) ToSqlserverflexInstanceFlavorPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceFlavorPtrOutput { + return o +} + +func (o SqlserverflexInstanceFlavorPtrOutput) Elem() SqlserverflexInstanceFlavorOutput { + return o.ApplyT(func(v *SqlserverflexInstanceFlavor) SqlserverflexInstanceFlavor { + if v != nil { + return *v + } + var ret SqlserverflexInstanceFlavor + return ret + }).(SqlserverflexInstanceFlavorOutput) +} + +func (o SqlserverflexInstanceFlavorPtrOutput) Cpu() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Cpu + }).(pulumi.IntPtrOutput) +} + +func (o SqlserverflexInstanceFlavorPtrOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Description + }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceFlavorPtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceFlavor) *string { + if v == nil { + return nil + } + return v.Id + }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceFlavorPtrOutput) Ram() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceFlavor) *int { + if v == nil { + return nil + } + return &v.Ram + }).(pulumi.IntPtrOutput) +} + +type SqlserverflexInstanceOptions struct { + Edition *string `pulumi:"edition"` + RetentionDays *int `pulumi:"retentionDays"` +} + +// SqlserverflexInstanceOptionsInput is an input type that accepts SqlserverflexInstanceOptionsArgs and SqlserverflexInstanceOptionsOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceOptionsInput` via: +// +// SqlserverflexInstanceOptionsArgs{...} +type SqlserverflexInstanceOptionsInput interface { + pulumi.Input + + ToSqlserverflexInstanceOptionsOutput() SqlserverflexInstanceOptionsOutput + ToSqlserverflexInstanceOptionsOutputWithContext(context.Context) SqlserverflexInstanceOptionsOutput +} + +type SqlserverflexInstanceOptionsArgs struct { + Edition pulumi.StringPtrInput `pulumi:"edition"` + RetentionDays pulumi.IntPtrInput `pulumi:"retentionDays"` +} + +func (SqlserverflexInstanceOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceOptions)(nil)).Elem() +} + +func (i SqlserverflexInstanceOptionsArgs) ToSqlserverflexInstanceOptionsOutput() SqlserverflexInstanceOptionsOutput { + return i.ToSqlserverflexInstanceOptionsOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceOptionsArgs) ToSqlserverflexInstanceOptionsOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceOptionsOutput) +} + +func (i SqlserverflexInstanceOptionsArgs) ToSqlserverflexInstanceOptionsPtrOutput() SqlserverflexInstanceOptionsPtrOutput { + return i.ToSqlserverflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceOptionsArgs) ToSqlserverflexInstanceOptionsPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceOptionsOutput).ToSqlserverflexInstanceOptionsPtrOutputWithContext(ctx) +} + +// SqlserverflexInstanceOptionsPtrInput is an input type that accepts SqlserverflexInstanceOptionsArgs, SqlserverflexInstanceOptionsPtr and SqlserverflexInstanceOptionsPtrOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceOptionsPtrInput` via: +// +// SqlserverflexInstanceOptionsArgs{...} +// +// or: +// +// nil +type SqlserverflexInstanceOptionsPtrInput interface { + pulumi.Input + + ToSqlserverflexInstanceOptionsPtrOutput() SqlserverflexInstanceOptionsPtrOutput + ToSqlserverflexInstanceOptionsPtrOutputWithContext(context.Context) SqlserverflexInstanceOptionsPtrOutput +} + +type sqlserverflexInstanceOptionsPtrType SqlserverflexInstanceOptionsArgs + +func SqlserverflexInstanceOptionsPtr(v *SqlserverflexInstanceOptionsArgs) SqlserverflexInstanceOptionsPtrInput { + return (*sqlserverflexInstanceOptionsPtrType)(v) +} + +func (*sqlserverflexInstanceOptionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceOptions)(nil)).Elem() +} + +func (i *sqlserverflexInstanceOptionsPtrType) ToSqlserverflexInstanceOptionsPtrOutput() SqlserverflexInstanceOptionsPtrOutput { + return i.ToSqlserverflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (i *sqlserverflexInstanceOptionsPtrType) ToSqlserverflexInstanceOptionsPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceOptionsPtrOutput) +} + +type SqlserverflexInstanceOptionsOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceOptions)(nil)).Elem() +} + +func (o SqlserverflexInstanceOptionsOutput) ToSqlserverflexInstanceOptionsOutput() SqlserverflexInstanceOptionsOutput { + return o +} + +func (o SqlserverflexInstanceOptionsOutput) ToSqlserverflexInstanceOptionsOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsOutput { + return o +} + +func (o SqlserverflexInstanceOptionsOutput) ToSqlserverflexInstanceOptionsPtrOutput() SqlserverflexInstanceOptionsPtrOutput { + return o.ToSqlserverflexInstanceOptionsPtrOutputWithContext(context.Background()) +} + +func (o SqlserverflexInstanceOptionsOutput) ToSqlserverflexInstanceOptionsPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SqlserverflexInstanceOptions) *SqlserverflexInstanceOptions { + return &v + }).(SqlserverflexInstanceOptionsPtrOutput) +} + +func (o SqlserverflexInstanceOptionsOutput) Edition() pulumi.StringPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceOptions) *string { return v.Edition }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceOptionsOutput) RetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceOptions) *int { return v.RetentionDays }).(pulumi.IntPtrOutput) +} + +type SqlserverflexInstanceOptionsPtrOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceOptionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceOptions)(nil)).Elem() +} + +func (o SqlserverflexInstanceOptionsPtrOutput) ToSqlserverflexInstanceOptionsPtrOutput() SqlserverflexInstanceOptionsPtrOutput { + return o +} + +func (o SqlserverflexInstanceOptionsPtrOutput) ToSqlserverflexInstanceOptionsPtrOutputWithContext(ctx context.Context) SqlserverflexInstanceOptionsPtrOutput { + return o +} + +func (o SqlserverflexInstanceOptionsPtrOutput) Elem() SqlserverflexInstanceOptionsOutput { + return o.ApplyT(func(v *SqlserverflexInstanceOptions) SqlserverflexInstanceOptions { + if v != nil { + return *v + } + var ret SqlserverflexInstanceOptions + return ret + }).(SqlserverflexInstanceOptionsOutput) +} + +func (o SqlserverflexInstanceOptionsPtrOutput) Edition() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceOptions) *string { + if v == nil { + return nil + } + return v.Edition + }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceOptionsPtrOutput) RetentionDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceOptions) *int { + if v == nil { + return nil + } + return v.RetentionDays + }).(pulumi.IntPtrOutput) +} + +type SqlserverflexInstanceStorage struct { + Class *string `pulumi:"class"` + Size *int `pulumi:"size"` +} + +// SqlserverflexInstanceStorageInput is an input type that accepts SqlserverflexInstanceStorageArgs and SqlserverflexInstanceStorageOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceStorageInput` via: +// +// SqlserverflexInstanceStorageArgs{...} +type SqlserverflexInstanceStorageInput interface { + pulumi.Input + + ToSqlserverflexInstanceStorageOutput() SqlserverflexInstanceStorageOutput + ToSqlserverflexInstanceStorageOutputWithContext(context.Context) SqlserverflexInstanceStorageOutput +} + +type SqlserverflexInstanceStorageArgs struct { + Class pulumi.StringPtrInput `pulumi:"class"` + Size pulumi.IntPtrInput `pulumi:"size"` +} + +func (SqlserverflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceStorage)(nil)).Elem() +} + +func (i SqlserverflexInstanceStorageArgs) ToSqlserverflexInstanceStorageOutput() SqlserverflexInstanceStorageOutput { + return i.ToSqlserverflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceStorageArgs) ToSqlserverflexInstanceStorageOutputWithContext(ctx context.Context) SqlserverflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceStorageOutput) +} + +func (i SqlserverflexInstanceStorageArgs) ToSqlserverflexInstanceStoragePtrOutput() SqlserverflexInstanceStoragePtrOutput { + return i.ToSqlserverflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceStorageArgs) ToSqlserverflexInstanceStoragePtrOutputWithContext(ctx context.Context) SqlserverflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceStorageOutput).ToSqlserverflexInstanceStoragePtrOutputWithContext(ctx) +} + +// SqlserverflexInstanceStoragePtrInput is an input type that accepts SqlserverflexInstanceStorageArgs, SqlserverflexInstanceStoragePtr and SqlserverflexInstanceStoragePtrOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceStoragePtrInput` via: +// +// SqlserverflexInstanceStorageArgs{...} +// +// or: +// +// nil +type SqlserverflexInstanceStoragePtrInput interface { + pulumi.Input + + ToSqlserverflexInstanceStoragePtrOutput() SqlserverflexInstanceStoragePtrOutput + ToSqlserverflexInstanceStoragePtrOutputWithContext(context.Context) SqlserverflexInstanceStoragePtrOutput +} + +type sqlserverflexInstanceStoragePtrType SqlserverflexInstanceStorageArgs + +func SqlserverflexInstanceStoragePtr(v *SqlserverflexInstanceStorageArgs) SqlserverflexInstanceStoragePtrInput { + return (*sqlserverflexInstanceStoragePtrType)(v) +} + +func (*sqlserverflexInstanceStoragePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceStorage)(nil)).Elem() +} + +func (i *sqlserverflexInstanceStoragePtrType) ToSqlserverflexInstanceStoragePtrOutput() SqlserverflexInstanceStoragePtrOutput { + return i.ToSqlserverflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (i *sqlserverflexInstanceStoragePtrType) ToSqlserverflexInstanceStoragePtrOutputWithContext(ctx context.Context) SqlserverflexInstanceStoragePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceStoragePtrOutput) +} + +type SqlserverflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*SqlserverflexInstanceStorage)(nil)).Elem() +} + +func (o SqlserverflexInstanceStorageOutput) ToSqlserverflexInstanceStorageOutput() SqlserverflexInstanceStorageOutput { + return o +} + +func (o SqlserverflexInstanceStorageOutput) ToSqlserverflexInstanceStorageOutputWithContext(ctx context.Context) SqlserverflexInstanceStorageOutput { + return o +} + +func (o SqlserverflexInstanceStorageOutput) ToSqlserverflexInstanceStoragePtrOutput() SqlserverflexInstanceStoragePtrOutput { + return o.ToSqlserverflexInstanceStoragePtrOutputWithContext(context.Background()) +} + +func (o SqlserverflexInstanceStorageOutput) ToSqlserverflexInstanceStoragePtrOutputWithContext(ctx context.Context) SqlserverflexInstanceStoragePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v SqlserverflexInstanceStorage) *SqlserverflexInstanceStorage { + return &v + }).(SqlserverflexInstanceStoragePtrOutput) +} + +func (o SqlserverflexInstanceStorageOutput) Class() pulumi.StringPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceStorage) *string { return v.Class }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceStorageOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v SqlserverflexInstanceStorage) *int { return v.Size }).(pulumi.IntPtrOutput) +} + +type SqlserverflexInstanceStoragePtrOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceStoragePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstanceStorage)(nil)).Elem() +} + +func (o SqlserverflexInstanceStoragePtrOutput) ToSqlserverflexInstanceStoragePtrOutput() SqlserverflexInstanceStoragePtrOutput { + return o +} + +func (o SqlserverflexInstanceStoragePtrOutput) ToSqlserverflexInstanceStoragePtrOutputWithContext(ctx context.Context) SqlserverflexInstanceStoragePtrOutput { + return o +} + +func (o SqlserverflexInstanceStoragePtrOutput) Elem() SqlserverflexInstanceStorageOutput { + return o.ApplyT(func(v *SqlserverflexInstanceStorage) SqlserverflexInstanceStorage { + if v != nil { + return *v + } + var ret SqlserverflexInstanceStorage + return ret + }).(SqlserverflexInstanceStorageOutput) +} + +func (o SqlserverflexInstanceStoragePtrOutput) Class() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceStorage) *string { + if v == nil { + return nil + } + return v.Class + }).(pulumi.StringPtrOutput) +} + +func (o SqlserverflexInstanceStoragePtrOutput) Size() pulumi.IntPtrOutput { + return o.ApplyT(func(v *SqlserverflexInstanceStorage) *int { + if v == nil { + return nil + } + return v.Size + }).(pulumi.IntPtrOutput) +} + +type VolumeSource struct { + // The ID of the source, e.g. image ID + Id string `pulumi:"id"` + // The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + Type string `pulumi:"type"` +} + +// VolumeSourceInput is an input type that accepts VolumeSourceArgs and VolumeSourceOutput values. +// You can construct a concrete instance of `VolumeSourceInput` via: +// +// VolumeSourceArgs{...} +type VolumeSourceInput interface { + pulumi.Input + + ToVolumeSourceOutput() VolumeSourceOutput + ToVolumeSourceOutputWithContext(context.Context) VolumeSourceOutput +} + +type VolumeSourceArgs struct { + // The ID of the source, e.g. image ID + Id pulumi.StringInput `pulumi:"id"` + // The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + Type pulumi.StringInput `pulumi:"type"` +} + +func (VolumeSourceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*VolumeSource)(nil)).Elem() +} + +func (i VolumeSourceArgs) ToVolumeSourceOutput() VolumeSourceOutput { + return i.ToVolumeSourceOutputWithContext(context.Background()) +} + +func (i VolumeSourceArgs) ToVolumeSourceOutputWithContext(ctx context.Context) VolumeSourceOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeSourceOutput) +} + +func (i VolumeSourceArgs) ToVolumeSourcePtrOutput() VolumeSourcePtrOutput { + return i.ToVolumeSourcePtrOutputWithContext(context.Background()) +} + +func (i VolumeSourceArgs) ToVolumeSourcePtrOutputWithContext(ctx context.Context) VolumeSourcePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeSourceOutput).ToVolumeSourcePtrOutputWithContext(ctx) +} + +// VolumeSourcePtrInput is an input type that accepts VolumeSourceArgs, VolumeSourcePtr and VolumeSourcePtrOutput values. +// You can construct a concrete instance of `VolumeSourcePtrInput` via: +// +// VolumeSourceArgs{...} +// +// or: +// +// nil +type VolumeSourcePtrInput interface { + pulumi.Input + + ToVolumeSourcePtrOutput() VolumeSourcePtrOutput + ToVolumeSourcePtrOutputWithContext(context.Context) VolumeSourcePtrOutput +} + +type volumeSourcePtrType VolumeSourceArgs + +func VolumeSourcePtr(v *VolumeSourceArgs) VolumeSourcePtrInput { + return (*volumeSourcePtrType)(v) +} + +func (*volumeSourcePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**VolumeSource)(nil)).Elem() +} + +func (i *volumeSourcePtrType) ToVolumeSourcePtrOutput() VolumeSourcePtrOutput { + return i.ToVolumeSourcePtrOutputWithContext(context.Background()) +} + +func (i *volumeSourcePtrType) ToVolumeSourcePtrOutputWithContext(ctx context.Context) VolumeSourcePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeSourcePtrOutput) +} + +type VolumeSourceOutput struct{ *pulumi.OutputState } + +func (VolumeSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*VolumeSource)(nil)).Elem() +} + +func (o VolumeSourceOutput) ToVolumeSourceOutput() VolumeSourceOutput { + return o +} + +func (o VolumeSourceOutput) ToVolumeSourceOutputWithContext(ctx context.Context) VolumeSourceOutput { + return o +} + +func (o VolumeSourceOutput) ToVolumeSourcePtrOutput() VolumeSourcePtrOutput { + return o.ToVolumeSourcePtrOutputWithContext(context.Background()) +} + +func (o VolumeSourceOutput) ToVolumeSourcePtrOutputWithContext(ctx context.Context) VolumeSourcePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v VolumeSource) *VolumeSource { + return &v + }).(VolumeSourcePtrOutput) +} + +// The ID of the source, e.g. image ID +func (o VolumeSourceOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v VolumeSource) string { return v.Id }).(pulumi.StringOutput) +} + +// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. +func (o VolumeSourceOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v VolumeSource) string { return v.Type }).(pulumi.StringOutput) +} + +type VolumeSourcePtrOutput struct{ *pulumi.OutputState } + +func (VolumeSourcePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**VolumeSource)(nil)).Elem() +} + +func (o VolumeSourcePtrOutput) ToVolumeSourcePtrOutput() VolumeSourcePtrOutput { + return o +} + +func (o VolumeSourcePtrOutput) ToVolumeSourcePtrOutputWithContext(ctx context.Context) VolumeSourcePtrOutput { + return o +} + +func (o VolumeSourcePtrOutput) Elem() VolumeSourceOutput { + return o.ApplyT(func(v *VolumeSource) VolumeSource { + if v != nil { + return *v + } + var ret VolumeSource + return ret + }).(VolumeSourceOutput) +} + +// The ID of the source, e.g. image ID +func (o VolumeSourcePtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *VolumeSource) *string { + if v == nil { + return nil + } + return &v.Id + }).(pulumi.StringPtrOutput) +} + +// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. +func (o VolumeSourcePtrOutput) Type() pulumi.StringPtrOutput { + return o.ApplyT(func(v *VolumeSource) *string { + if v == nil { + return nil + } + return &v.Type + }).(pulumi.StringPtrOutput) +} + +type GetCdnDistributionConfig struct { + // The configured backend for the distribution + Backend GetCdnDistributionConfigBackend `pulumi:"backend"` + // The configured regions where content will be hosted + Regions []string `pulumi:"regions"` +} + +// GetCdnDistributionConfigInput is an input type that accepts GetCdnDistributionConfigArgs and GetCdnDistributionConfigOutput values. +// You can construct a concrete instance of `GetCdnDistributionConfigInput` via: +// +// GetCdnDistributionConfigArgs{...} +type GetCdnDistributionConfigInput interface { + pulumi.Input + + ToGetCdnDistributionConfigOutput() GetCdnDistributionConfigOutput + ToGetCdnDistributionConfigOutputWithContext(context.Context) GetCdnDistributionConfigOutput +} + +type GetCdnDistributionConfigArgs struct { + // The configured backend for the distribution + Backend GetCdnDistributionConfigBackendInput `pulumi:"backend"` + // The configured regions where content will be hosted + Regions pulumi.StringArrayInput `pulumi:"regions"` +} + +func (GetCdnDistributionConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionConfig)(nil)).Elem() +} + +func (i GetCdnDistributionConfigArgs) ToGetCdnDistributionConfigOutput() GetCdnDistributionConfigOutput { + return i.ToGetCdnDistributionConfigOutputWithContext(context.Background()) +} + +func (i GetCdnDistributionConfigArgs) ToGetCdnDistributionConfigOutputWithContext(ctx context.Context) GetCdnDistributionConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCdnDistributionConfigOutput) +} + +type GetCdnDistributionConfigOutput struct{ *pulumi.OutputState } + +func (GetCdnDistributionConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionConfig)(nil)).Elem() +} + +func (o GetCdnDistributionConfigOutput) ToGetCdnDistributionConfigOutput() GetCdnDistributionConfigOutput { + return o +} + +func (o GetCdnDistributionConfigOutput) ToGetCdnDistributionConfigOutputWithContext(ctx context.Context) GetCdnDistributionConfigOutput { + return o +} + +// The configured backend for the distribution +func (o GetCdnDistributionConfigOutput) Backend() GetCdnDistributionConfigBackendOutput { + return o.ApplyT(func(v GetCdnDistributionConfig) GetCdnDistributionConfigBackend { return v.Backend }).(GetCdnDistributionConfigBackendOutput) +} + +// The configured regions where content will be hosted +func (o GetCdnDistributionConfigOutput) Regions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetCdnDistributionConfig) []string { return v.Regions }).(pulumi.StringArrayOutput) +} + +type GetCdnDistributionConfigBackend struct { + // The configured origin request headers for the backend + OriginRequestHeaders map[string]string `pulumi:"originRequestHeaders"` + // The configured backend type for the distribution + OriginUrl string `pulumi:"originUrl"` + // The configured backend type. Supported values are: `http`. + Type string `pulumi:"type"` +} + +// GetCdnDistributionConfigBackendInput is an input type that accepts GetCdnDistributionConfigBackendArgs and GetCdnDistributionConfigBackendOutput values. +// You can construct a concrete instance of `GetCdnDistributionConfigBackendInput` via: +// +// GetCdnDistributionConfigBackendArgs{...} +type GetCdnDistributionConfigBackendInput interface { + pulumi.Input + + ToGetCdnDistributionConfigBackendOutput() GetCdnDistributionConfigBackendOutput + ToGetCdnDistributionConfigBackendOutputWithContext(context.Context) GetCdnDistributionConfigBackendOutput +} + +type GetCdnDistributionConfigBackendArgs struct { + // The configured origin request headers for the backend + OriginRequestHeaders pulumi.StringMapInput `pulumi:"originRequestHeaders"` + // The configured backend type for the distribution + OriginUrl pulumi.StringInput `pulumi:"originUrl"` + // The configured backend type. Supported values are: `http`. + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetCdnDistributionConfigBackendArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionConfigBackend)(nil)).Elem() +} + +func (i GetCdnDistributionConfigBackendArgs) ToGetCdnDistributionConfigBackendOutput() GetCdnDistributionConfigBackendOutput { + return i.ToGetCdnDistributionConfigBackendOutputWithContext(context.Background()) +} + +func (i GetCdnDistributionConfigBackendArgs) ToGetCdnDistributionConfigBackendOutputWithContext(ctx context.Context) GetCdnDistributionConfigBackendOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCdnDistributionConfigBackendOutput) +} + +type GetCdnDistributionConfigBackendOutput struct{ *pulumi.OutputState } + +func (GetCdnDistributionConfigBackendOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionConfigBackend)(nil)).Elem() +} + +func (o GetCdnDistributionConfigBackendOutput) ToGetCdnDistributionConfigBackendOutput() GetCdnDistributionConfigBackendOutput { + return o +} + +func (o GetCdnDistributionConfigBackendOutput) ToGetCdnDistributionConfigBackendOutputWithContext(ctx context.Context) GetCdnDistributionConfigBackendOutput { + return o +} + +// The configured origin request headers for the backend +func (o GetCdnDistributionConfigBackendOutput) OriginRequestHeaders() pulumi.StringMapOutput { + return o.ApplyT(func(v GetCdnDistributionConfigBackend) map[string]string { return v.OriginRequestHeaders }).(pulumi.StringMapOutput) +} + +// The configured backend type for the distribution +func (o GetCdnDistributionConfigBackendOutput) OriginUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCdnDistributionConfigBackend) string { return v.OriginUrl }).(pulumi.StringOutput) +} + +// The configured backend type. Supported values are: `http`. +func (o GetCdnDistributionConfigBackendOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetCdnDistributionConfigBackend) string { return v.Type }).(pulumi.StringOutput) +} + +type GetCdnDistributionDomain struct { + // List of domain errors + Errors []string `pulumi:"errors"` + // The name of the domain + Name string `pulumi:"name"` + // The status of the domain + Status string `pulumi:"status"` + // The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + Type string `pulumi:"type"` +} + +// GetCdnDistributionDomainInput is an input type that accepts GetCdnDistributionDomainArgs and GetCdnDistributionDomainOutput values. +// You can construct a concrete instance of `GetCdnDistributionDomainInput` via: +// +// GetCdnDistributionDomainArgs{...} +type GetCdnDistributionDomainInput interface { + pulumi.Input + + ToGetCdnDistributionDomainOutput() GetCdnDistributionDomainOutput + ToGetCdnDistributionDomainOutputWithContext(context.Context) GetCdnDistributionDomainOutput +} + +type GetCdnDistributionDomainArgs struct { + // List of domain errors + Errors pulumi.StringArrayInput `pulumi:"errors"` + // The name of the domain + Name pulumi.StringInput `pulumi:"name"` + // The status of the domain + Status pulumi.StringInput `pulumi:"status"` + // The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetCdnDistributionDomainArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionDomain)(nil)).Elem() +} + +func (i GetCdnDistributionDomainArgs) ToGetCdnDistributionDomainOutput() GetCdnDistributionDomainOutput { + return i.ToGetCdnDistributionDomainOutputWithContext(context.Background()) +} + +func (i GetCdnDistributionDomainArgs) ToGetCdnDistributionDomainOutputWithContext(ctx context.Context) GetCdnDistributionDomainOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCdnDistributionDomainOutput) +} + +// GetCdnDistributionDomainArrayInput is an input type that accepts GetCdnDistributionDomainArray and GetCdnDistributionDomainArrayOutput values. +// You can construct a concrete instance of `GetCdnDistributionDomainArrayInput` via: +// +// GetCdnDistributionDomainArray{ GetCdnDistributionDomainArgs{...} } +type GetCdnDistributionDomainArrayInput interface { + pulumi.Input + + ToGetCdnDistributionDomainArrayOutput() GetCdnDistributionDomainArrayOutput + ToGetCdnDistributionDomainArrayOutputWithContext(context.Context) GetCdnDistributionDomainArrayOutput +} + +type GetCdnDistributionDomainArray []GetCdnDistributionDomainInput + +func (GetCdnDistributionDomainArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCdnDistributionDomain)(nil)).Elem() +} + +func (i GetCdnDistributionDomainArray) ToGetCdnDistributionDomainArrayOutput() GetCdnDistributionDomainArrayOutput { + return i.ToGetCdnDistributionDomainArrayOutputWithContext(context.Background()) +} + +func (i GetCdnDistributionDomainArray) ToGetCdnDistributionDomainArrayOutputWithContext(ctx context.Context) GetCdnDistributionDomainArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCdnDistributionDomainArrayOutput) +} + +type GetCdnDistributionDomainOutput struct{ *pulumi.OutputState } + +func (GetCdnDistributionDomainOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCdnDistributionDomain)(nil)).Elem() +} + +func (o GetCdnDistributionDomainOutput) ToGetCdnDistributionDomainOutput() GetCdnDistributionDomainOutput { + return o +} + +func (o GetCdnDistributionDomainOutput) ToGetCdnDistributionDomainOutputWithContext(ctx context.Context) GetCdnDistributionDomainOutput { + return o +} + +// List of domain errors +func (o GetCdnDistributionDomainOutput) Errors() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetCdnDistributionDomain) []string { return v.Errors }).(pulumi.StringArrayOutput) +} + +// The name of the domain +func (o GetCdnDistributionDomainOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetCdnDistributionDomain) string { return v.Name }).(pulumi.StringOutput) +} + +// The status of the domain +func (o GetCdnDistributionDomainOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v GetCdnDistributionDomain) string { return v.Status }).(pulumi.StringOutput) +} + +// The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user +func (o GetCdnDistributionDomainOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetCdnDistributionDomain) string { return v.Type }).(pulumi.StringOutput) +} + +type GetCdnDistributionDomainArrayOutput struct{ *pulumi.OutputState } + +func (GetCdnDistributionDomainArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCdnDistributionDomain)(nil)).Elem() +} + +func (o GetCdnDistributionDomainArrayOutput) ToGetCdnDistributionDomainArrayOutput() GetCdnDistributionDomainArrayOutput { + return o +} + +func (o GetCdnDistributionDomainArrayOutput) ToGetCdnDistributionDomainArrayOutputWithContext(ctx context.Context) GetCdnDistributionDomainArrayOutput { + return o +} + +func (o GetCdnDistributionDomainArrayOutput) Index(i pulumi.IntInput) GetCdnDistributionDomainOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetCdnDistributionDomain { + return vs[0].([]GetCdnDistributionDomain)[vs[1].(int)] + }).(GetCdnDistributionDomainOutput) +} + +type GetImageChecksum struct { + // Algorithm for the checksum of the image data. + Algorithm string `pulumi:"algorithm"` + // Hexdigest of the checksum of the image data. + Digest string `pulumi:"digest"` +} + +// GetImageChecksumInput is an input type that accepts GetImageChecksumArgs and GetImageChecksumOutput values. +// You can construct a concrete instance of `GetImageChecksumInput` via: +// +// GetImageChecksumArgs{...} +type GetImageChecksumInput interface { + pulumi.Input + + ToGetImageChecksumOutput() GetImageChecksumOutput + ToGetImageChecksumOutputWithContext(context.Context) GetImageChecksumOutput +} + +type GetImageChecksumArgs struct { + // Algorithm for the checksum of the image data. + Algorithm pulumi.StringInput `pulumi:"algorithm"` + // Hexdigest of the checksum of the image data. + Digest pulumi.StringInput `pulumi:"digest"` +} + +func (GetImageChecksumArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetImageChecksum)(nil)).Elem() +} + +func (i GetImageChecksumArgs) ToGetImageChecksumOutput() GetImageChecksumOutput { + return i.ToGetImageChecksumOutputWithContext(context.Background()) +} + +func (i GetImageChecksumArgs) ToGetImageChecksumOutputWithContext(ctx context.Context) GetImageChecksumOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetImageChecksumOutput) +} + +type GetImageChecksumOutput struct{ *pulumi.OutputState } + +func (GetImageChecksumOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetImageChecksum)(nil)).Elem() +} + +func (o GetImageChecksumOutput) ToGetImageChecksumOutput() GetImageChecksumOutput { + return o +} + +func (o GetImageChecksumOutput) ToGetImageChecksumOutputWithContext(ctx context.Context) GetImageChecksumOutput { + return o +} + +// Algorithm for the checksum of the image data. +func (o GetImageChecksumOutput) Algorithm() pulumi.StringOutput { + return o.ApplyT(func(v GetImageChecksum) string { return v.Algorithm }).(pulumi.StringOutput) +} + +// Hexdigest of the checksum of the image data. +func (o GetImageChecksumOutput) Digest() pulumi.StringOutput { + return o.ApplyT(func(v GetImageChecksum) string { return v.Digest }).(pulumi.StringOutput) +} + +type GetImageConfig struct { + // Enables the BIOS bootmenu. + BootMenu bool `pulumi:"bootMenu"` + // Sets CDROM bus controller type. + CdromBus string `pulumi:"cdromBus"` + // Sets Disk bus controller type. + DiskBus string `pulumi:"diskBus"` + // Sets virtual network interface model. + NicModel string `pulumi:"nicModel"` + // Enables operating system specific optimizations. + OperatingSystem string `pulumi:"operatingSystem"` + // Operating system distribution. + OperatingSystemDistro string `pulumi:"operatingSystemDistro"` + // Version of the operating system. + OperatingSystemVersion string `pulumi:"operatingSystemVersion"` + // Sets the device bus when the image is used as a rescue image. + RescueBus string `pulumi:"rescueBus"` + // Sets the device when the image is used as a rescue image. + RescueDevice string `pulumi:"rescueDevice"` + // Enables Secure Boot. + SecureBoot bool `pulumi:"secureBoot"` + // Enables UEFI boot. + Uefi bool `pulumi:"uefi"` + // Sets Graphic device model. + VideoModel string `pulumi:"videoModel"` + // Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + VirtioScsi bool `pulumi:"virtioScsi"` +} + +// GetImageConfigInput is an input type that accepts GetImageConfigArgs and GetImageConfigOutput values. +// You can construct a concrete instance of `GetImageConfigInput` via: +// +// GetImageConfigArgs{...} +type GetImageConfigInput interface { + pulumi.Input + + ToGetImageConfigOutput() GetImageConfigOutput + ToGetImageConfigOutputWithContext(context.Context) GetImageConfigOutput +} + +type GetImageConfigArgs struct { + // Enables the BIOS bootmenu. + BootMenu pulumi.BoolInput `pulumi:"bootMenu"` + // Sets CDROM bus controller type. + CdromBus pulumi.StringInput `pulumi:"cdromBus"` + // Sets Disk bus controller type. + DiskBus pulumi.StringInput `pulumi:"diskBus"` + // Sets virtual network interface model. + NicModel pulumi.StringInput `pulumi:"nicModel"` + // Enables operating system specific optimizations. + OperatingSystem pulumi.StringInput `pulumi:"operatingSystem"` + // Operating system distribution. + OperatingSystemDistro pulumi.StringInput `pulumi:"operatingSystemDistro"` + // Version of the operating system. + OperatingSystemVersion pulumi.StringInput `pulumi:"operatingSystemVersion"` + // Sets the device bus when the image is used as a rescue image. + RescueBus pulumi.StringInput `pulumi:"rescueBus"` + // Sets the device when the image is used as a rescue image. + RescueDevice pulumi.StringInput `pulumi:"rescueDevice"` + // Enables Secure Boot. + SecureBoot pulumi.BoolInput `pulumi:"secureBoot"` + // Enables UEFI boot. + Uefi pulumi.BoolInput `pulumi:"uefi"` + // Sets Graphic device model. + VideoModel pulumi.StringInput `pulumi:"videoModel"` + // Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + VirtioScsi pulumi.BoolInput `pulumi:"virtioScsi"` +} + +func (GetImageConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetImageConfig)(nil)).Elem() +} + +func (i GetImageConfigArgs) ToGetImageConfigOutput() GetImageConfigOutput { + return i.ToGetImageConfigOutputWithContext(context.Background()) +} + +func (i GetImageConfigArgs) ToGetImageConfigOutputWithContext(ctx context.Context) GetImageConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetImageConfigOutput) +} + +type GetImageConfigOutput struct{ *pulumi.OutputState } + +func (GetImageConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetImageConfig)(nil)).Elem() +} + +func (o GetImageConfigOutput) ToGetImageConfigOutput() GetImageConfigOutput { + return o +} + +func (o GetImageConfigOutput) ToGetImageConfigOutputWithContext(ctx context.Context) GetImageConfigOutput { + return o +} + +// Enables the BIOS bootmenu. +func (o GetImageConfigOutput) BootMenu() pulumi.BoolOutput { + return o.ApplyT(func(v GetImageConfig) bool { return v.BootMenu }).(pulumi.BoolOutput) +} + +// Sets CDROM bus controller type. +func (o GetImageConfigOutput) CdromBus() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.CdromBus }).(pulumi.StringOutput) +} + +// Sets Disk bus controller type. +func (o GetImageConfigOutput) DiskBus() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.DiskBus }).(pulumi.StringOutput) +} + +// Sets virtual network interface model. +func (o GetImageConfigOutput) NicModel() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.NicModel }).(pulumi.StringOutput) +} + +// Enables operating system specific optimizations. +func (o GetImageConfigOutput) OperatingSystem() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.OperatingSystem }).(pulumi.StringOutput) +} + +// Operating system distribution. +func (o GetImageConfigOutput) OperatingSystemDistro() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.OperatingSystemDistro }).(pulumi.StringOutput) +} + +// Version of the operating system. +func (o GetImageConfigOutput) OperatingSystemVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.OperatingSystemVersion }).(pulumi.StringOutput) +} + +// Sets the device bus when the image is used as a rescue image. +func (o GetImageConfigOutput) RescueBus() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.RescueBus }).(pulumi.StringOutput) +} + +// Sets the device when the image is used as a rescue image. +func (o GetImageConfigOutput) RescueDevice() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.RescueDevice }).(pulumi.StringOutput) +} + +// Enables Secure Boot. +func (o GetImageConfigOutput) SecureBoot() pulumi.BoolOutput { + return o.ApplyT(func(v GetImageConfig) bool { return v.SecureBoot }).(pulumi.BoolOutput) +} + +// Enables UEFI boot. +func (o GetImageConfigOutput) Uefi() pulumi.BoolOutput { + return o.ApplyT(func(v GetImageConfig) bool { return v.Uefi }).(pulumi.BoolOutput) +} + +// Sets Graphic device model. +func (o GetImageConfigOutput) VideoModel() pulumi.StringOutput { + return o.ApplyT(func(v GetImageConfig) string { return v.VideoModel }).(pulumi.StringOutput) +} + +// Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. +func (o GetImageConfigOutput) VirtioScsi() pulumi.BoolOutput { + return o.ApplyT(func(v GetImageConfig) bool { return v.VirtioScsi }).(pulumi.BoolOutput) +} + +type GetLoadbalancerListener struct { + DisplayName string `pulumi:"displayName"` + // Port number where we listen for traffic. + Port int `pulumi:"port"` + // Protocol is the highest network protocol we understand to load balance. + Protocol string `pulumi:"protocol"` + // A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + ServerNameIndicators []GetLoadbalancerListenerServerNameIndicator `pulumi:"serverNameIndicators"` + // Reference target pool by target pool name. + TargetPool string `pulumi:"targetPool"` +} + +// GetLoadbalancerListenerInput is an input type that accepts GetLoadbalancerListenerArgs and GetLoadbalancerListenerOutput values. +// You can construct a concrete instance of `GetLoadbalancerListenerInput` via: +// +// GetLoadbalancerListenerArgs{...} +type GetLoadbalancerListenerInput interface { + pulumi.Input + + ToGetLoadbalancerListenerOutput() GetLoadbalancerListenerOutput + ToGetLoadbalancerListenerOutputWithContext(context.Context) GetLoadbalancerListenerOutput +} + +type GetLoadbalancerListenerArgs struct { + DisplayName pulumi.StringInput `pulumi:"displayName"` + // Port number where we listen for traffic. + Port pulumi.IntInput `pulumi:"port"` + // Protocol is the highest network protocol we understand to load balance. + Protocol pulumi.StringInput `pulumi:"protocol"` + // A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + ServerNameIndicators GetLoadbalancerListenerServerNameIndicatorArrayInput `pulumi:"serverNameIndicators"` + // Reference target pool by target pool name. + TargetPool pulumi.StringInput `pulumi:"targetPool"` +} + +func (GetLoadbalancerListenerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerListener)(nil)).Elem() +} + +func (i GetLoadbalancerListenerArgs) ToGetLoadbalancerListenerOutput() GetLoadbalancerListenerOutput { + return i.ToGetLoadbalancerListenerOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerListenerArgs) ToGetLoadbalancerListenerOutputWithContext(ctx context.Context) GetLoadbalancerListenerOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerListenerOutput) +} + +// GetLoadbalancerListenerArrayInput is an input type that accepts GetLoadbalancerListenerArray and GetLoadbalancerListenerArrayOutput values. +// You can construct a concrete instance of `GetLoadbalancerListenerArrayInput` via: +// +// GetLoadbalancerListenerArray{ GetLoadbalancerListenerArgs{...} } +type GetLoadbalancerListenerArrayInput interface { + pulumi.Input + + ToGetLoadbalancerListenerArrayOutput() GetLoadbalancerListenerArrayOutput + ToGetLoadbalancerListenerArrayOutputWithContext(context.Context) GetLoadbalancerListenerArrayOutput +} + +type GetLoadbalancerListenerArray []GetLoadbalancerListenerInput + +func (GetLoadbalancerListenerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerListener)(nil)).Elem() +} + +func (i GetLoadbalancerListenerArray) ToGetLoadbalancerListenerArrayOutput() GetLoadbalancerListenerArrayOutput { + return i.ToGetLoadbalancerListenerArrayOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerListenerArray) ToGetLoadbalancerListenerArrayOutputWithContext(ctx context.Context) GetLoadbalancerListenerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerListenerArrayOutput) +} + +type GetLoadbalancerListenerOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerListenerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerListener)(nil)).Elem() +} + +func (o GetLoadbalancerListenerOutput) ToGetLoadbalancerListenerOutput() GetLoadbalancerListenerOutput { + return o +} + +func (o GetLoadbalancerListenerOutput) ToGetLoadbalancerListenerOutputWithContext(ctx context.Context) GetLoadbalancerListenerOutput { + return o +} + +func (o GetLoadbalancerListenerOutput) DisplayName() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerListener) string { return v.DisplayName }).(pulumi.StringOutput) +} + +// Port number where we listen for traffic. +func (o GetLoadbalancerListenerOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v GetLoadbalancerListener) int { return v.Port }).(pulumi.IntOutput) +} + +// Protocol is the highest network protocol we understand to load balance. +func (o GetLoadbalancerListenerOutput) Protocol() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerListener) string { return v.Protocol }).(pulumi.StringOutput) +} + +// A list of domain names to match in order to pass TLS traffic to the target pool in the current listener +func (o GetLoadbalancerListenerOutput) ServerNameIndicators() GetLoadbalancerListenerServerNameIndicatorArrayOutput { + return o.ApplyT(func(v GetLoadbalancerListener) []GetLoadbalancerListenerServerNameIndicator { + return v.ServerNameIndicators + }).(GetLoadbalancerListenerServerNameIndicatorArrayOutput) +} + +// Reference target pool by target pool name. +func (o GetLoadbalancerListenerOutput) TargetPool() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerListener) string { return v.TargetPool }).(pulumi.StringOutput) +} + +type GetLoadbalancerListenerArrayOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerListenerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerListener)(nil)).Elem() +} + +func (o GetLoadbalancerListenerArrayOutput) ToGetLoadbalancerListenerArrayOutput() GetLoadbalancerListenerArrayOutput { + return o +} + +func (o GetLoadbalancerListenerArrayOutput) ToGetLoadbalancerListenerArrayOutputWithContext(ctx context.Context) GetLoadbalancerListenerArrayOutput { + return o +} + +func (o GetLoadbalancerListenerArrayOutput) Index(i pulumi.IntInput) GetLoadbalancerListenerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLoadbalancerListener { + return vs[0].([]GetLoadbalancerListener)[vs[1].(int)] + }).(GetLoadbalancerListenerOutput) +} + +type GetLoadbalancerListenerServerNameIndicator struct { + // A domain name to match in order to pass TLS traffic to the target pool in the current listener + Name *string `pulumi:"name"` +} + +// GetLoadbalancerListenerServerNameIndicatorInput is an input type that accepts GetLoadbalancerListenerServerNameIndicatorArgs and GetLoadbalancerListenerServerNameIndicatorOutput values. +// You can construct a concrete instance of `GetLoadbalancerListenerServerNameIndicatorInput` via: +// +// GetLoadbalancerListenerServerNameIndicatorArgs{...} +type GetLoadbalancerListenerServerNameIndicatorInput interface { + pulumi.Input + + ToGetLoadbalancerListenerServerNameIndicatorOutput() GetLoadbalancerListenerServerNameIndicatorOutput + ToGetLoadbalancerListenerServerNameIndicatorOutputWithContext(context.Context) GetLoadbalancerListenerServerNameIndicatorOutput +} + +type GetLoadbalancerListenerServerNameIndicatorArgs struct { + // A domain name to match in order to pass TLS traffic to the target pool in the current listener + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetLoadbalancerListenerServerNameIndicatorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (i GetLoadbalancerListenerServerNameIndicatorArgs) ToGetLoadbalancerListenerServerNameIndicatorOutput() GetLoadbalancerListenerServerNameIndicatorOutput { + return i.ToGetLoadbalancerListenerServerNameIndicatorOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerListenerServerNameIndicatorArgs) ToGetLoadbalancerListenerServerNameIndicatorOutputWithContext(ctx context.Context) GetLoadbalancerListenerServerNameIndicatorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerListenerServerNameIndicatorOutput) +} + +// GetLoadbalancerListenerServerNameIndicatorArrayInput is an input type that accepts GetLoadbalancerListenerServerNameIndicatorArray and GetLoadbalancerListenerServerNameIndicatorArrayOutput values. +// You can construct a concrete instance of `GetLoadbalancerListenerServerNameIndicatorArrayInput` via: +// +// GetLoadbalancerListenerServerNameIndicatorArray{ GetLoadbalancerListenerServerNameIndicatorArgs{...} } +type GetLoadbalancerListenerServerNameIndicatorArrayInput interface { + pulumi.Input + + ToGetLoadbalancerListenerServerNameIndicatorArrayOutput() GetLoadbalancerListenerServerNameIndicatorArrayOutput + ToGetLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(context.Context) GetLoadbalancerListenerServerNameIndicatorArrayOutput +} + +type GetLoadbalancerListenerServerNameIndicatorArray []GetLoadbalancerListenerServerNameIndicatorInput + +func (GetLoadbalancerListenerServerNameIndicatorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (i GetLoadbalancerListenerServerNameIndicatorArray) ToGetLoadbalancerListenerServerNameIndicatorArrayOutput() GetLoadbalancerListenerServerNameIndicatorArrayOutput { + return i.ToGetLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerListenerServerNameIndicatorArray) ToGetLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(ctx context.Context) GetLoadbalancerListenerServerNameIndicatorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerListenerServerNameIndicatorArrayOutput) +} + +type GetLoadbalancerListenerServerNameIndicatorOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerListenerServerNameIndicatorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (o GetLoadbalancerListenerServerNameIndicatorOutput) ToGetLoadbalancerListenerServerNameIndicatorOutput() GetLoadbalancerListenerServerNameIndicatorOutput { + return o +} + +func (o GetLoadbalancerListenerServerNameIndicatorOutput) ToGetLoadbalancerListenerServerNameIndicatorOutputWithContext(ctx context.Context) GetLoadbalancerListenerServerNameIndicatorOutput { + return o +} + +// A domain name to match in order to pass TLS traffic to the target pool in the current listener +func (o GetLoadbalancerListenerServerNameIndicatorOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetLoadbalancerListenerServerNameIndicator) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +type GetLoadbalancerListenerServerNameIndicatorArrayOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerListenerServerNameIndicatorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerListenerServerNameIndicator)(nil)).Elem() +} + +func (o GetLoadbalancerListenerServerNameIndicatorArrayOutput) ToGetLoadbalancerListenerServerNameIndicatorArrayOutput() GetLoadbalancerListenerServerNameIndicatorArrayOutput { + return o +} + +func (o GetLoadbalancerListenerServerNameIndicatorArrayOutput) ToGetLoadbalancerListenerServerNameIndicatorArrayOutputWithContext(ctx context.Context) GetLoadbalancerListenerServerNameIndicatorArrayOutput { + return o +} + +func (o GetLoadbalancerListenerServerNameIndicatorArrayOutput) Index(i pulumi.IntInput) GetLoadbalancerListenerServerNameIndicatorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLoadbalancerListenerServerNameIndicator { + return vs[0].([]GetLoadbalancerListenerServerNameIndicator)[vs[1].(int)] + }).(GetLoadbalancerListenerServerNameIndicatorOutput) +} + +type GetLoadbalancerNetwork struct { + // Openstack network ID. + NetworkId string `pulumi:"networkId"` + // The role defines how the load balancer is using the network. + Role string `pulumi:"role"` +} + +// GetLoadbalancerNetworkInput is an input type that accepts GetLoadbalancerNetworkArgs and GetLoadbalancerNetworkOutput values. +// You can construct a concrete instance of `GetLoadbalancerNetworkInput` via: +// +// GetLoadbalancerNetworkArgs{...} +type GetLoadbalancerNetworkInput interface { + pulumi.Input + + ToGetLoadbalancerNetworkOutput() GetLoadbalancerNetworkOutput + ToGetLoadbalancerNetworkOutputWithContext(context.Context) GetLoadbalancerNetworkOutput +} + +type GetLoadbalancerNetworkArgs struct { + // Openstack network ID. + NetworkId pulumi.StringInput `pulumi:"networkId"` + // The role defines how the load balancer is using the network. + Role pulumi.StringInput `pulumi:"role"` +} + +func (GetLoadbalancerNetworkArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerNetwork)(nil)).Elem() +} + +func (i GetLoadbalancerNetworkArgs) ToGetLoadbalancerNetworkOutput() GetLoadbalancerNetworkOutput { + return i.ToGetLoadbalancerNetworkOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerNetworkArgs) ToGetLoadbalancerNetworkOutputWithContext(ctx context.Context) GetLoadbalancerNetworkOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerNetworkOutput) +} + +// GetLoadbalancerNetworkArrayInput is an input type that accepts GetLoadbalancerNetworkArray and GetLoadbalancerNetworkArrayOutput values. +// You can construct a concrete instance of `GetLoadbalancerNetworkArrayInput` via: +// +// GetLoadbalancerNetworkArray{ GetLoadbalancerNetworkArgs{...} } +type GetLoadbalancerNetworkArrayInput interface { + pulumi.Input + + ToGetLoadbalancerNetworkArrayOutput() GetLoadbalancerNetworkArrayOutput + ToGetLoadbalancerNetworkArrayOutputWithContext(context.Context) GetLoadbalancerNetworkArrayOutput +} + +type GetLoadbalancerNetworkArray []GetLoadbalancerNetworkInput + +func (GetLoadbalancerNetworkArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerNetwork)(nil)).Elem() +} + +func (i GetLoadbalancerNetworkArray) ToGetLoadbalancerNetworkArrayOutput() GetLoadbalancerNetworkArrayOutput { + return i.ToGetLoadbalancerNetworkArrayOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerNetworkArray) ToGetLoadbalancerNetworkArrayOutputWithContext(ctx context.Context) GetLoadbalancerNetworkArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerNetworkArrayOutput) +} + +type GetLoadbalancerNetworkOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerNetworkOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerNetwork)(nil)).Elem() +} + +func (o GetLoadbalancerNetworkOutput) ToGetLoadbalancerNetworkOutput() GetLoadbalancerNetworkOutput { + return o +} + +func (o GetLoadbalancerNetworkOutput) ToGetLoadbalancerNetworkOutputWithContext(ctx context.Context) GetLoadbalancerNetworkOutput { + return o +} + +// Openstack network ID. +func (o GetLoadbalancerNetworkOutput) NetworkId() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerNetwork) string { return v.NetworkId }).(pulumi.StringOutput) +} + +// The role defines how the load balancer is using the network. +func (o GetLoadbalancerNetworkOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerNetwork) string { return v.Role }).(pulumi.StringOutput) +} + +type GetLoadbalancerNetworkArrayOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerNetworkArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerNetwork)(nil)).Elem() +} + +func (o GetLoadbalancerNetworkArrayOutput) ToGetLoadbalancerNetworkArrayOutput() GetLoadbalancerNetworkArrayOutput { + return o +} + +func (o GetLoadbalancerNetworkArrayOutput) ToGetLoadbalancerNetworkArrayOutputWithContext(ctx context.Context) GetLoadbalancerNetworkArrayOutput { + return o +} + +func (o GetLoadbalancerNetworkArrayOutput) Index(i pulumi.IntInput) GetLoadbalancerNetworkOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLoadbalancerNetwork { + return vs[0].([]GetLoadbalancerNetwork)[vs[1].(int)] + }).(GetLoadbalancerNetworkOutput) +} + +type GetLoadbalancerOptions struct { + // Load Balancer is accessible only from an IP address in this range. + Acls []string `pulumi:"acls"` + // We offer Load Balancer metrics observability via ARGUS or external solutions. + Observability GetLoadbalancerOptionsObservability `pulumi:"observability"` + // If true, Load Balancer is accessible only via a private network IP address. + PrivateNetworkOnly bool `pulumi:"privateNetworkOnly"` +} + +// GetLoadbalancerOptionsInput is an input type that accepts GetLoadbalancerOptionsArgs and GetLoadbalancerOptionsOutput values. +// You can construct a concrete instance of `GetLoadbalancerOptionsInput` via: +// +// GetLoadbalancerOptionsArgs{...} +type GetLoadbalancerOptionsInput interface { + pulumi.Input + + ToGetLoadbalancerOptionsOutput() GetLoadbalancerOptionsOutput + ToGetLoadbalancerOptionsOutputWithContext(context.Context) GetLoadbalancerOptionsOutput +} + +type GetLoadbalancerOptionsArgs struct { + // Load Balancer is accessible only from an IP address in this range. + Acls pulumi.StringArrayInput `pulumi:"acls"` + // We offer Load Balancer metrics observability via ARGUS or external solutions. + Observability GetLoadbalancerOptionsObservabilityInput `pulumi:"observability"` + // If true, Load Balancer is accessible only via a private network IP address. + PrivateNetworkOnly pulumi.BoolInput `pulumi:"privateNetworkOnly"` +} + +func (GetLoadbalancerOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptions)(nil)).Elem() +} + +func (i GetLoadbalancerOptionsArgs) ToGetLoadbalancerOptionsOutput() GetLoadbalancerOptionsOutput { + return i.ToGetLoadbalancerOptionsOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerOptionsArgs) ToGetLoadbalancerOptionsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerOptionsOutput) +} + +type GetLoadbalancerOptionsOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptions)(nil)).Elem() +} + +func (o GetLoadbalancerOptionsOutput) ToGetLoadbalancerOptionsOutput() GetLoadbalancerOptionsOutput { + return o +} + +func (o GetLoadbalancerOptionsOutput) ToGetLoadbalancerOptionsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsOutput { + return o +} + +// Load Balancer is accessible only from an IP address in this range. +func (o GetLoadbalancerOptionsOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetLoadbalancerOptions) []string { return v.Acls }).(pulumi.StringArrayOutput) +} + +// We offer Load Balancer metrics observability via ARGUS or external solutions. +func (o GetLoadbalancerOptionsOutput) Observability() GetLoadbalancerOptionsObservabilityOutput { + return o.ApplyT(func(v GetLoadbalancerOptions) GetLoadbalancerOptionsObservability { return v.Observability }).(GetLoadbalancerOptionsObservabilityOutput) +} + +// If true, Load Balancer is accessible only via a private network IP address. +func (o GetLoadbalancerOptionsOutput) PrivateNetworkOnly() pulumi.BoolOutput { + return o.ApplyT(func(v GetLoadbalancerOptions) bool { return v.PrivateNetworkOnly }).(pulumi.BoolOutput) +} + +type GetLoadbalancerOptionsObservability struct { + // Observability logs configuration. + Logs GetLoadbalancerOptionsObservabilityLogs `pulumi:"logs"` + // Observability metrics configuration. + Metrics GetLoadbalancerOptionsObservabilityMetrics `pulumi:"metrics"` +} + +// GetLoadbalancerOptionsObservabilityInput is an input type that accepts GetLoadbalancerOptionsObservabilityArgs and GetLoadbalancerOptionsObservabilityOutput values. +// You can construct a concrete instance of `GetLoadbalancerOptionsObservabilityInput` via: +// +// GetLoadbalancerOptionsObservabilityArgs{...} +type GetLoadbalancerOptionsObservabilityInput interface { + pulumi.Input + + ToGetLoadbalancerOptionsObservabilityOutput() GetLoadbalancerOptionsObservabilityOutput + ToGetLoadbalancerOptionsObservabilityOutputWithContext(context.Context) GetLoadbalancerOptionsObservabilityOutput +} + +type GetLoadbalancerOptionsObservabilityArgs struct { + // Observability logs configuration. + Logs GetLoadbalancerOptionsObservabilityLogsInput `pulumi:"logs"` + // Observability metrics configuration. + Metrics GetLoadbalancerOptionsObservabilityMetricsInput `pulumi:"metrics"` +} + +func (GetLoadbalancerOptionsObservabilityArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservability)(nil)).Elem() +} + +func (i GetLoadbalancerOptionsObservabilityArgs) ToGetLoadbalancerOptionsObservabilityOutput() GetLoadbalancerOptionsObservabilityOutput { + return i.ToGetLoadbalancerOptionsObservabilityOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerOptionsObservabilityArgs) ToGetLoadbalancerOptionsObservabilityOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerOptionsObservabilityOutput) +} + +type GetLoadbalancerOptionsObservabilityOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerOptionsObservabilityOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservability)(nil)).Elem() +} + +func (o GetLoadbalancerOptionsObservabilityOutput) ToGetLoadbalancerOptionsObservabilityOutput() GetLoadbalancerOptionsObservabilityOutput { + return o +} + +func (o GetLoadbalancerOptionsObservabilityOutput) ToGetLoadbalancerOptionsObservabilityOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityOutput { + return o +} + +// Observability logs configuration. +func (o GetLoadbalancerOptionsObservabilityOutput) Logs() GetLoadbalancerOptionsObservabilityLogsOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservability) GetLoadbalancerOptionsObservabilityLogs { return v.Logs }).(GetLoadbalancerOptionsObservabilityLogsOutput) +} + +// Observability metrics configuration. +func (o GetLoadbalancerOptionsObservabilityOutput) Metrics() GetLoadbalancerOptionsObservabilityMetricsOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservability) GetLoadbalancerOptionsObservabilityMetrics { + return v.Metrics + }).(GetLoadbalancerOptionsObservabilityMetricsOutput) +} + +type GetLoadbalancerOptionsObservabilityLogs struct { + // Credentials reference for logs. + CredentialsRef string `pulumi:"credentialsRef"` + // Credentials reference for logs. + PushUrl string `pulumi:"pushUrl"` +} + +// GetLoadbalancerOptionsObservabilityLogsInput is an input type that accepts GetLoadbalancerOptionsObservabilityLogsArgs and GetLoadbalancerOptionsObservabilityLogsOutput values. +// You can construct a concrete instance of `GetLoadbalancerOptionsObservabilityLogsInput` via: +// +// GetLoadbalancerOptionsObservabilityLogsArgs{...} +type GetLoadbalancerOptionsObservabilityLogsInput interface { + pulumi.Input + + ToGetLoadbalancerOptionsObservabilityLogsOutput() GetLoadbalancerOptionsObservabilityLogsOutput + ToGetLoadbalancerOptionsObservabilityLogsOutputWithContext(context.Context) GetLoadbalancerOptionsObservabilityLogsOutput +} + +type GetLoadbalancerOptionsObservabilityLogsArgs struct { + // Credentials reference for logs. + CredentialsRef pulumi.StringInput `pulumi:"credentialsRef"` + // Credentials reference for logs. + PushUrl pulumi.StringInput `pulumi:"pushUrl"` +} + +func (GetLoadbalancerOptionsObservabilityLogsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (i GetLoadbalancerOptionsObservabilityLogsArgs) ToGetLoadbalancerOptionsObservabilityLogsOutput() GetLoadbalancerOptionsObservabilityLogsOutput { + return i.ToGetLoadbalancerOptionsObservabilityLogsOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerOptionsObservabilityLogsArgs) ToGetLoadbalancerOptionsObservabilityLogsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityLogsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerOptionsObservabilityLogsOutput) +} + +type GetLoadbalancerOptionsObservabilityLogsOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerOptionsObservabilityLogsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservabilityLogs)(nil)).Elem() +} + +func (o GetLoadbalancerOptionsObservabilityLogsOutput) ToGetLoadbalancerOptionsObservabilityLogsOutput() GetLoadbalancerOptionsObservabilityLogsOutput { + return o +} + +func (o GetLoadbalancerOptionsObservabilityLogsOutput) ToGetLoadbalancerOptionsObservabilityLogsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityLogsOutput { + return o +} + +// Credentials reference for logs. +func (o GetLoadbalancerOptionsObservabilityLogsOutput) CredentialsRef() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservabilityLogs) string { return v.CredentialsRef }).(pulumi.StringOutput) +} + +// Credentials reference for logs. +func (o GetLoadbalancerOptionsObservabilityLogsOutput) PushUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservabilityLogs) string { return v.PushUrl }).(pulumi.StringOutput) +} + +type GetLoadbalancerOptionsObservabilityMetrics struct { + // Credentials reference for metrics. + CredentialsRef string `pulumi:"credentialsRef"` + // Credentials reference for metrics. + PushUrl string `pulumi:"pushUrl"` +} + +// GetLoadbalancerOptionsObservabilityMetricsInput is an input type that accepts GetLoadbalancerOptionsObservabilityMetricsArgs and GetLoadbalancerOptionsObservabilityMetricsOutput values. +// You can construct a concrete instance of `GetLoadbalancerOptionsObservabilityMetricsInput` via: +// +// GetLoadbalancerOptionsObservabilityMetricsArgs{...} +type GetLoadbalancerOptionsObservabilityMetricsInput interface { + pulumi.Input + + ToGetLoadbalancerOptionsObservabilityMetricsOutput() GetLoadbalancerOptionsObservabilityMetricsOutput + ToGetLoadbalancerOptionsObservabilityMetricsOutputWithContext(context.Context) GetLoadbalancerOptionsObservabilityMetricsOutput +} + +type GetLoadbalancerOptionsObservabilityMetricsArgs struct { + // Credentials reference for metrics. + CredentialsRef pulumi.StringInput `pulumi:"credentialsRef"` + // Credentials reference for metrics. + PushUrl pulumi.StringInput `pulumi:"pushUrl"` +} + +func (GetLoadbalancerOptionsObservabilityMetricsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (i GetLoadbalancerOptionsObservabilityMetricsArgs) ToGetLoadbalancerOptionsObservabilityMetricsOutput() GetLoadbalancerOptionsObservabilityMetricsOutput { + return i.ToGetLoadbalancerOptionsObservabilityMetricsOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerOptionsObservabilityMetricsArgs) ToGetLoadbalancerOptionsObservabilityMetricsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityMetricsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerOptionsObservabilityMetricsOutput) +} + +type GetLoadbalancerOptionsObservabilityMetricsOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerOptionsObservabilityMetricsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerOptionsObservabilityMetrics)(nil)).Elem() +} + +func (o GetLoadbalancerOptionsObservabilityMetricsOutput) ToGetLoadbalancerOptionsObservabilityMetricsOutput() GetLoadbalancerOptionsObservabilityMetricsOutput { + return o +} + +func (o GetLoadbalancerOptionsObservabilityMetricsOutput) ToGetLoadbalancerOptionsObservabilityMetricsOutputWithContext(ctx context.Context) GetLoadbalancerOptionsObservabilityMetricsOutput { + return o +} + +// Credentials reference for metrics. +func (o GetLoadbalancerOptionsObservabilityMetricsOutput) CredentialsRef() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservabilityMetrics) string { return v.CredentialsRef }).(pulumi.StringOutput) +} + +// Credentials reference for metrics. +func (o GetLoadbalancerOptionsObservabilityMetricsOutput) PushUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerOptionsObservabilityMetrics) string { return v.PushUrl }).(pulumi.StringOutput) +} + +type GetLoadbalancerTargetPool struct { + ActiveHealthCheck GetLoadbalancerTargetPoolActiveHealthCheck `pulumi:"activeHealthCheck"` + // Target pool name. + Name string `pulumi:"name"` + // Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + SessionPersistence *GetLoadbalancerTargetPoolSessionPersistence `pulumi:"sessionPersistence"` + // Identical port number where each target listens for traffic. + TargetPort int `pulumi:"targetPort"` + // List of all targets which will be used in the pool. Limited to 1000. + Targets []GetLoadbalancerTargetPoolTarget `pulumi:"targets"` +} + +// GetLoadbalancerTargetPoolInput is an input type that accepts GetLoadbalancerTargetPoolArgs and GetLoadbalancerTargetPoolOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolInput` via: +// +// GetLoadbalancerTargetPoolArgs{...} +type GetLoadbalancerTargetPoolInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolOutput() GetLoadbalancerTargetPoolOutput + ToGetLoadbalancerTargetPoolOutputWithContext(context.Context) GetLoadbalancerTargetPoolOutput +} + +type GetLoadbalancerTargetPoolArgs struct { + ActiveHealthCheck GetLoadbalancerTargetPoolActiveHealthCheckInput `pulumi:"activeHealthCheck"` + // Target pool name. + Name pulumi.StringInput `pulumi:"name"` + // Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + SessionPersistence GetLoadbalancerTargetPoolSessionPersistencePtrInput `pulumi:"sessionPersistence"` + // Identical port number where each target listens for traffic. + TargetPort pulumi.IntInput `pulumi:"targetPort"` + // List of all targets which will be used in the pool. Limited to 1000. + Targets GetLoadbalancerTargetPoolTargetArrayInput `pulumi:"targets"` +} + +func (GetLoadbalancerTargetPoolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPool)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolArgs) ToGetLoadbalancerTargetPoolOutput() GetLoadbalancerTargetPoolOutput { + return i.ToGetLoadbalancerTargetPoolOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolArgs) ToGetLoadbalancerTargetPoolOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolOutput) +} + +// GetLoadbalancerTargetPoolArrayInput is an input type that accepts GetLoadbalancerTargetPoolArray and GetLoadbalancerTargetPoolArrayOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolArrayInput` via: +// +// GetLoadbalancerTargetPoolArray{ GetLoadbalancerTargetPoolArgs{...} } +type GetLoadbalancerTargetPoolArrayInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolArrayOutput() GetLoadbalancerTargetPoolArrayOutput + ToGetLoadbalancerTargetPoolArrayOutputWithContext(context.Context) GetLoadbalancerTargetPoolArrayOutput +} + +type GetLoadbalancerTargetPoolArray []GetLoadbalancerTargetPoolInput + +func (GetLoadbalancerTargetPoolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerTargetPool)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolArray) ToGetLoadbalancerTargetPoolArrayOutput() GetLoadbalancerTargetPoolArrayOutput { + return i.ToGetLoadbalancerTargetPoolArrayOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolArray) ToGetLoadbalancerTargetPoolArrayOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolArrayOutput) +} + +type GetLoadbalancerTargetPoolOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPool)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolOutput) ToGetLoadbalancerTargetPoolOutput() GetLoadbalancerTargetPoolOutput { + return o +} + +func (o GetLoadbalancerTargetPoolOutput) ToGetLoadbalancerTargetPoolOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolOutput { + return o +} + +func (o GetLoadbalancerTargetPoolOutput) ActiveHealthCheck() GetLoadbalancerTargetPoolActiveHealthCheckOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPool) GetLoadbalancerTargetPoolActiveHealthCheck { + return v.ActiveHealthCheck + }).(GetLoadbalancerTargetPoolActiveHealthCheckOutput) +} + +// Target pool name. +func (o GetLoadbalancerTargetPoolOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPool) string { return v.Name }).(pulumi.StringOutput) +} + +// Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. +func (o GetLoadbalancerTargetPoolOutput) SessionPersistence() GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPool) *GetLoadbalancerTargetPoolSessionPersistence { + return v.SessionPersistence + }).(GetLoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +// Identical port number where each target listens for traffic. +func (o GetLoadbalancerTargetPoolOutput) TargetPort() pulumi.IntOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPool) int { return v.TargetPort }).(pulumi.IntOutput) +} + +// List of all targets which will be used in the pool. Limited to 1000. +func (o GetLoadbalancerTargetPoolOutput) Targets() GetLoadbalancerTargetPoolTargetArrayOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPool) []GetLoadbalancerTargetPoolTarget { return v.Targets }).(GetLoadbalancerTargetPoolTargetArrayOutput) +} + +type GetLoadbalancerTargetPoolArrayOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerTargetPool)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolArrayOutput) ToGetLoadbalancerTargetPoolArrayOutput() GetLoadbalancerTargetPoolArrayOutput { + return o +} + +func (o GetLoadbalancerTargetPoolArrayOutput) ToGetLoadbalancerTargetPoolArrayOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolArrayOutput { + return o +} + +func (o GetLoadbalancerTargetPoolArrayOutput) Index(i pulumi.IntInput) GetLoadbalancerTargetPoolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLoadbalancerTargetPool { + return vs[0].([]GetLoadbalancerTargetPool)[vs[1].(int)] + }).(GetLoadbalancerTargetPoolOutput) +} + +type GetLoadbalancerTargetPoolActiveHealthCheck struct { + // Healthy threshold of the health checking. + HealthyThreshold int `pulumi:"healthyThreshold"` + // Interval duration of health checking in seconds. + Interval string `pulumi:"interval"` + // Interval duration threshold of the health checking in seconds. + IntervalJitter string `pulumi:"intervalJitter"` + // Active health checking timeout duration in seconds. + Timeout string `pulumi:"timeout"` + // Unhealthy threshold of the health checking. + UnhealthyThreshold int `pulumi:"unhealthyThreshold"` +} + +// GetLoadbalancerTargetPoolActiveHealthCheckInput is an input type that accepts GetLoadbalancerTargetPoolActiveHealthCheckArgs and GetLoadbalancerTargetPoolActiveHealthCheckOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolActiveHealthCheckInput` via: +// +// GetLoadbalancerTargetPoolActiveHealthCheckArgs{...} +type GetLoadbalancerTargetPoolActiveHealthCheckInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolActiveHealthCheckOutput() GetLoadbalancerTargetPoolActiveHealthCheckOutput + ToGetLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(context.Context) GetLoadbalancerTargetPoolActiveHealthCheckOutput +} + +type GetLoadbalancerTargetPoolActiveHealthCheckArgs struct { + // Healthy threshold of the health checking. + HealthyThreshold pulumi.IntInput `pulumi:"healthyThreshold"` + // Interval duration of health checking in seconds. + Interval pulumi.StringInput `pulumi:"interval"` + // Interval duration threshold of the health checking in seconds. + IntervalJitter pulumi.StringInput `pulumi:"intervalJitter"` + // Active health checking timeout duration in seconds. + Timeout pulumi.StringInput `pulumi:"timeout"` + // Unhealthy threshold of the health checking. + UnhealthyThreshold pulumi.IntInput `pulumi:"unhealthyThreshold"` +} + +func (GetLoadbalancerTargetPoolActiveHealthCheckArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolActiveHealthCheckArgs) ToGetLoadbalancerTargetPoolActiveHealthCheckOutput() GetLoadbalancerTargetPoolActiveHealthCheckOutput { + return i.ToGetLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolActiveHealthCheckArgs) ToGetLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolActiveHealthCheckOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolActiveHealthCheckOutput) +} + +type GetLoadbalancerTargetPoolActiveHealthCheckOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolActiveHealthCheckOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolActiveHealthCheck)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) ToGetLoadbalancerTargetPoolActiveHealthCheckOutput() GetLoadbalancerTargetPoolActiveHealthCheckOutput { + return o +} + +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) ToGetLoadbalancerTargetPoolActiveHealthCheckOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolActiveHealthCheckOutput { + return o +} + +// Healthy threshold of the health checking. +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) HealthyThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolActiveHealthCheck) int { return v.HealthyThreshold }).(pulumi.IntOutput) +} + +// Interval duration of health checking in seconds. +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) Interval() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolActiveHealthCheck) string { return v.Interval }).(pulumi.StringOutput) +} + +// Interval duration threshold of the health checking in seconds. +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) IntervalJitter() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolActiveHealthCheck) string { return v.IntervalJitter }).(pulumi.StringOutput) +} + +// Active health checking timeout duration in seconds. +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) Timeout() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolActiveHealthCheck) string { return v.Timeout }).(pulumi.StringOutput) +} + +// Unhealthy threshold of the health checking. +func (o GetLoadbalancerTargetPoolActiveHealthCheckOutput) UnhealthyThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolActiveHealthCheck) int { return v.UnhealthyThreshold }).(pulumi.IntOutput) +} + +type GetLoadbalancerTargetPoolSessionPersistence struct { + // If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + UseSourceIpAddress *bool `pulumi:"useSourceIpAddress"` +} + +// GetLoadbalancerTargetPoolSessionPersistenceInput is an input type that accepts GetLoadbalancerTargetPoolSessionPersistenceArgs and GetLoadbalancerTargetPoolSessionPersistenceOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolSessionPersistenceInput` via: +// +// GetLoadbalancerTargetPoolSessionPersistenceArgs{...} +type GetLoadbalancerTargetPoolSessionPersistenceInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolSessionPersistenceOutput() GetLoadbalancerTargetPoolSessionPersistenceOutput + ToGetLoadbalancerTargetPoolSessionPersistenceOutputWithContext(context.Context) GetLoadbalancerTargetPoolSessionPersistenceOutput +} + +type GetLoadbalancerTargetPoolSessionPersistenceArgs struct { + // If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + UseSourceIpAddress pulumi.BoolPtrInput `pulumi:"useSourceIpAddress"` +} + +func (GetLoadbalancerTargetPoolSessionPersistenceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolSessionPersistenceArgs) ToGetLoadbalancerTargetPoolSessionPersistenceOutput() GetLoadbalancerTargetPoolSessionPersistenceOutput { + return i.ToGetLoadbalancerTargetPoolSessionPersistenceOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolSessionPersistenceArgs) ToGetLoadbalancerTargetPoolSessionPersistenceOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistenceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolSessionPersistenceOutput) +} + +func (i GetLoadbalancerTargetPoolSessionPersistenceArgs) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutput() GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return i.ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolSessionPersistenceArgs) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolSessionPersistenceOutput).ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx) +} + +// GetLoadbalancerTargetPoolSessionPersistencePtrInput is an input type that accepts GetLoadbalancerTargetPoolSessionPersistenceArgs, GetLoadbalancerTargetPoolSessionPersistencePtr and GetLoadbalancerTargetPoolSessionPersistencePtrOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolSessionPersistencePtrInput` via: +// +// GetLoadbalancerTargetPoolSessionPersistenceArgs{...} +// +// or: +// +// nil +type GetLoadbalancerTargetPoolSessionPersistencePtrInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolSessionPersistencePtrOutput() GetLoadbalancerTargetPoolSessionPersistencePtrOutput + ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Context) GetLoadbalancerTargetPoolSessionPersistencePtrOutput +} + +type getLoadbalancerTargetPoolSessionPersistencePtrType GetLoadbalancerTargetPoolSessionPersistenceArgs + +func GetLoadbalancerTargetPoolSessionPersistencePtr(v *GetLoadbalancerTargetPoolSessionPersistenceArgs) GetLoadbalancerTargetPoolSessionPersistencePtrInput { + return (*getLoadbalancerTargetPoolSessionPersistencePtrType)(v) +} + +func (*getLoadbalancerTargetPoolSessionPersistencePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**GetLoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (i *getLoadbalancerTargetPoolSessionPersistencePtrType) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutput() GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return i.ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (i *getLoadbalancerTargetPoolSessionPersistencePtrType) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +type GetLoadbalancerTargetPoolSessionPersistenceOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolSessionPersistenceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolSessionPersistenceOutput) ToGetLoadbalancerTargetPoolSessionPersistenceOutput() GetLoadbalancerTargetPoolSessionPersistenceOutput { + return o +} + +func (o GetLoadbalancerTargetPoolSessionPersistenceOutput) ToGetLoadbalancerTargetPoolSessionPersistenceOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistenceOutput { + return o +} + +func (o GetLoadbalancerTargetPoolSessionPersistenceOutput) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutput() GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(context.Background()) +} + +func (o GetLoadbalancerTargetPoolSessionPersistenceOutput) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v GetLoadbalancerTargetPoolSessionPersistence) *GetLoadbalancerTargetPoolSessionPersistence { + return &v + }).(GetLoadbalancerTargetPoolSessionPersistencePtrOutput) +} + +// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. +func (o GetLoadbalancerTargetPoolSessionPersistenceOutput) UseSourceIpAddress() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolSessionPersistence) *bool { return v.UseSourceIpAddress }).(pulumi.BoolPtrOutput) +} + +type GetLoadbalancerTargetPoolSessionPersistencePtrOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolSessionPersistencePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**GetLoadbalancerTargetPoolSessionPersistence)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolSessionPersistencePtrOutput) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutput() GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return o +} + +func (o GetLoadbalancerTargetPoolSessionPersistencePtrOutput) ToGetLoadbalancerTargetPoolSessionPersistencePtrOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolSessionPersistencePtrOutput { + return o +} + +func (o GetLoadbalancerTargetPoolSessionPersistencePtrOutput) Elem() GetLoadbalancerTargetPoolSessionPersistenceOutput { + return o.ApplyT(func(v *GetLoadbalancerTargetPoolSessionPersistence) GetLoadbalancerTargetPoolSessionPersistence { + if v != nil { + return *v + } + var ret GetLoadbalancerTargetPoolSessionPersistence + return ret + }).(GetLoadbalancerTargetPoolSessionPersistenceOutput) +} + +// If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. +func (o GetLoadbalancerTargetPoolSessionPersistencePtrOutput) UseSourceIpAddress() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *GetLoadbalancerTargetPoolSessionPersistence) *bool { + if v == nil { + return nil + } + return v.UseSourceIpAddress + }).(pulumi.BoolPtrOutput) +} + +type GetLoadbalancerTargetPoolTarget struct { + // Target display name + DisplayName string `pulumi:"displayName"` + // Target IP + Ip string `pulumi:"ip"` +} + +// GetLoadbalancerTargetPoolTargetInput is an input type that accepts GetLoadbalancerTargetPoolTargetArgs and GetLoadbalancerTargetPoolTargetOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolTargetInput` via: +// +// GetLoadbalancerTargetPoolTargetArgs{...} +type GetLoadbalancerTargetPoolTargetInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolTargetOutput() GetLoadbalancerTargetPoolTargetOutput + ToGetLoadbalancerTargetPoolTargetOutputWithContext(context.Context) GetLoadbalancerTargetPoolTargetOutput +} + +type GetLoadbalancerTargetPoolTargetArgs struct { + // Target display name + DisplayName pulumi.StringInput `pulumi:"displayName"` + // Target IP + Ip pulumi.StringInput `pulumi:"ip"` +} + +func (GetLoadbalancerTargetPoolTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolTargetArgs) ToGetLoadbalancerTargetPoolTargetOutput() GetLoadbalancerTargetPoolTargetOutput { + return i.ToGetLoadbalancerTargetPoolTargetOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolTargetArgs) ToGetLoadbalancerTargetPoolTargetOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolTargetOutput) +} + +// GetLoadbalancerTargetPoolTargetArrayInput is an input type that accepts GetLoadbalancerTargetPoolTargetArray and GetLoadbalancerTargetPoolTargetArrayOutput values. +// You can construct a concrete instance of `GetLoadbalancerTargetPoolTargetArrayInput` via: +// +// GetLoadbalancerTargetPoolTargetArray{ GetLoadbalancerTargetPoolTargetArgs{...} } +type GetLoadbalancerTargetPoolTargetArrayInput interface { + pulumi.Input + + ToGetLoadbalancerTargetPoolTargetArrayOutput() GetLoadbalancerTargetPoolTargetArrayOutput + ToGetLoadbalancerTargetPoolTargetArrayOutputWithContext(context.Context) GetLoadbalancerTargetPoolTargetArrayOutput +} + +type GetLoadbalancerTargetPoolTargetArray []GetLoadbalancerTargetPoolTargetInput + +func (GetLoadbalancerTargetPoolTargetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (i GetLoadbalancerTargetPoolTargetArray) ToGetLoadbalancerTargetPoolTargetArrayOutput() GetLoadbalancerTargetPoolTargetArrayOutput { + return i.ToGetLoadbalancerTargetPoolTargetArrayOutputWithContext(context.Background()) +} + +func (i GetLoadbalancerTargetPoolTargetArray) ToGetLoadbalancerTargetPoolTargetArrayOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolTargetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLoadbalancerTargetPoolTargetArrayOutput) +} + +type GetLoadbalancerTargetPoolTargetOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolTargetOutput) ToGetLoadbalancerTargetPoolTargetOutput() GetLoadbalancerTargetPoolTargetOutput { + return o +} + +func (o GetLoadbalancerTargetPoolTargetOutput) ToGetLoadbalancerTargetPoolTargetOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolTargetOutput { + return o +} + +// Target display name +func (o GetLoadbalancerTargetPoolTargetOutput) DisplayName() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolTarget) string { return v.DisplayName }).(pulumi.StringOutput) +} + +// Target IP +func (o GetLoadbalancerTargetPoolTargetOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v GetLoadbalancerTargetPoolTarget) string { return v.Ip }).(pulumi.StringOutput) +} + +type GetLoadbalancerTargetPoolTargetArrayOutput struct{ *pulumi.OutputState } + +func (GetLoadbalancerTargetPoolTargetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetLoadbalancerTargetPoolTarget)(nil)).Elem() +} + +func (o GetLoadbalancerTargetPoolTargetArrayOutput) ToGetLoadbalancerTargetPoolTargetArrayOutput() GetLoadbalancerTargetPoolTargetArrayOutput { + return o +} + +func (o GetLoadbalancerTargetPoolTargetArrayOutput) ToGetLoadbalancerTargetPoolTargetArrayOutputWithContext(ctx context.Context) GetLoadbalancerTargetPoolTargetArrayOutput { + return o +} + +func (o GetLoadbalancerTargetPoolTargetArrayOutput) Index(i pulumi.IntInput) GetLoadbalancerTargetPoolTargetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetLoadbalancerTargetPoolTarget { + return vs[0].([]GetLoadbalancerTargetPoolTarget)[vs[1].(int)] + }).(GetLoadbalancerTargetPoolTargetOutput) +} + +type GetLogmeInstanceParameters struct { + // Enable monitoring. + EnableMonitoring bool `pulumi:"enableMonitoring"` + FluentdTcp int `pulumi:"fluentdTcp"` + FluentdTls int `pulumi:"fluentdTls"` + FluentdTlsCiphers string `pulumi:"fluentdTlsCiphers"` + FluentdTlsMaxVersion string `pulumi:"fluentdTlsMaxVersion"` + FluentdTlsMinVersion string `pulumi:"fluentdTlsMinVersion"` + FluentdTlsVersion string `pulumi:"fluentdTlsVersion"` + FluentdUdp int `pulumi:"fluentdUdp"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite string `pulumi:"graphite"` + // Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + IsmDeletionAfter string `pulumi:"ismDeletionAfter"` + IsmJitter float64 `pulumi:"ismJitter"` + // Jitter of the execution time. + IsmJobInterval int `pulumi:"ismJobInterval"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace int `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace int `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId string `pulumi:"monitoringInstanceId"` + OpensearchTlsCiphers []string `pulumi:"opensearchTlsCiphers"` + OpensearchTlsProtocols []string `pulumi:"opensearchTlsProtocols"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` +} + +// GetLogmeInstanceParametersInput is an input type that accepts GetLogmeInstanceParametersArgs and GetLogmeInstanceParametersOutput values. +// You can construct a concrete instance of `GetLogmeInstanceParametersInput` via: +// +// GetLogmeInstanceParametersArgs{...} +type GetLogmeInstanceParametersInput interface { + pulumi.Input + + ToGetLogmeInstanceParametersOutput() GetLogmeInstanceParametersOutput + ToGetLogmeInstanceParametersOutputWithContext(context.Context) GetLogmeInstanceParametersOutput +} + +type GetLogmeInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolInput `pulumi:"enableMonitoring"` + FluentdTcp pulumi.IntInput `pulumi:"fluentdTcp"` + FluentdTls pulumi.IntInput `pulumi:"fluentdTls"` + FluentdTlsCiphers pulumi.StringInput `pulumi:"fluentdTlsCiphers"` + FluentdTlsMaxVersion pulumi.StringInput `pulumi:"fluentdTlsMaxVersion"` + FluentdTlsMinVersion pulumi.StringInput `pulumi:"fluentdTlsMinVersion"` + FluentdTlsVersion pulumi.StringInput `pulumi:"fluentdTlsVersion"` + FluentdUdp pulumi.IntInput `pulumi:"fluentdUdp"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite pulumi.StringInput `pulumi:"graphite"` + // Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + IsmDeletionAfter pulumi.StringInput `pulumi:"ismDeletionAfter"` + IsmJitter pulumi.Float64Input `pulumi:"ismJitter"` + // Jitter of the execution time. + IsmJobInterval pulumi.IntInput `pulumi:"ismJobInterval"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace pulumi.IntInput `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace pulumi.IntInput `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency pulumi.IntInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix pulumi.StringInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringInput `pulumi:"monitoringInstanceId"` + OpensearchTlsCiphers pulumi.StringArrayInput `pulumi:"opensearchTlsCiphers"` + OpensearchTlsProtocols pulumi.StringArrayInput `pulumi:"opensearchTlsProtocols"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` +} + +func (GetLogmeInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetLogmeInstanceParameters)(nil)).Elem() +} + +func (i GetLogmeInstanceParametersArgs) ToGetLogmeInstanceParametersOutput() GetLogmeInstanceParametersOutput { + return i.ToGetLogmeInstanceParametersOutputWithContext(context.Background()) +} + +func (i GetLogmeInstanceParametersArgs) ToGetLogmeInstanceParametersOutputWithContext(ctx context.Context) GetLogmeInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetLogmeInstanceParametersOutput) +} + +type GetLogmeInstanceParametersOutput struct{ *pulumi.OutputState } + +func (GetLogmeInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetLogmeInstanceParameters)(nil)).Elem() +} + +func (o GetLogmeInstanceParametersOutput) ToGetLogmeInstanceParametersOutput() GetLogmeInstanceParametersOutput { + return o +} + +func (o GetLogmeInstanceParametersOutput) ToGetLogmeInstanceParametersOutputWithContext(ctx context.Context) GetLogmeInstanceParametersOutput { + return o +} + +// Enable monitoring. +func (o GetLogmeInstanceParametersOutput) EnableMonitoring() pulumi.BoolOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) bool { return v.EnableMonitoring }).(pulumi.BoolOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTcp() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.FluentdTcp }).(pulumi.IntOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTls() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.FluentdTls }).(pulumi.IntOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTlsCiphers() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.FluentdTlsCiphers }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTlsMaxVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.FluentdTlsMaxVersion }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTlsMinVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.FluentdTlsMinVersion }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdTlsVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.FluentdTlsVersion }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) FluentdUdp() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.FluentdUdp }).(pulumi.IntOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o GetLogmeInstanceParametersOutput) Graphite() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.Graphite }).(pulumi.StringOutput) +} + +// Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. +func (o GetLogmeInstanceParametersOutput) IsmDeletionAfter() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.IsmDeletionAfter }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) IsmJitter() pulumi.Float64Output { + return o.ApplyT(func(v GetLogmeInstanceParameters) float64 { return v.IsmJitter }).(pulumi.Float64Output) +} + +// Jitter of the execution time. +func (o GetLogmeInstanceParametersOutput) IsmJobInterval() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.IsmJobInterval }).(pulumi.IntOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o GetLogmeInstanceParametersOutput) JavaHeapspace() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.JavaHeapspace }).(pulumi.IntOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o GetLogmeInstanceParametersOutput) JavaMaxmetaspace() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.JavaMaxmetaspace }).(pulumi.IntOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o GetLogmeInstanceParametersOutput) MaxDiskThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.MaxDiskThreshold }).(pulumi.IntOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o GetLogmeInstanceParametersOutput) MetricsFrequency() pulumi.IntOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) int { return v.MetricsFrequency }).(pulumi.IntOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o GetLogmeInstanceParametersOutput) MetricsPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.MetricsPrefix }).(pulumi.StringOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o GetLogmeInstanceParametersOutput) MonitoringInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.MonitoringInstanceId }).(pulumi.StringOutput) +} + +func (o GetLogmeInstanceParametersOutput) OpensearchTlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) []string { return v.OpensearchTlsCiphers }).(pulumi.StringArrayOutput) +} + +func (o GetLogmeInstanceParametersOutput) OpensearchTlsProtocols() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) []string { return v.OpensearchTlsProtocols }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o GetLogmeInstanceParametersOutput) SgwAcl() pulumi.StringOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) string { return v.SgwAcl }).(pulumi.StringOutput) +} + +// List of syslog servers to send logs to. +func (o GetLogmeInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetLogmeInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +type GetMariadbInstanceParameters struct { + // Enable monitoring. + EnableMonitoring bool `pulumi:"enableMonitoring"` + Graphite string `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId string `pulumi:"monitoringInstanceId"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` +} + +// GetMariadbInstanceParametersInput is an input type that accepts GetMariadbInstanceParametersArgs and GetMariadbInstanceParametersOutput values. +// You can construct a concrete instance of `GetMariadbInstanceParametersInput` via: +// +// GetMariadbInstanceParametersArgs{...} +type GetMariadbInstanceParametersInput interface { + pulumi.Input + + ToGetMariadbInstanceParametersOutput() GetMariadbInstanceParametersOutput + ToGetMariadbInstanceParametersOutputWithContext(context.Context) GetMariadbInstanceParametersOutput +} + +type GetMariadbInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolInput `pulumi:"enableMonitoring"` + Graphite pulumi.StringInput `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringInput `pulumi:"monitoringInstanceId"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` +} + +func (GetMariadbInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetMariadbInstanceParameters)(nil)).Elem() +} + +func (i GetMariadbInstanceParametersArgs) ToGetMariadbInstanceParametersOutput() GetMariadbInstanceParametersOutput { + return i.ToGetMariadbInstanceParametersOutputWithContext(context.Background()) +} + +func (i GetMariadbInstanceParametersArgs) ToGetMariadbInstanceParametersOutputWithContext(ctx context.Context) GetMariadbInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetMariadbInstanceParametersOutput) +} + +type GetMariadbInstanceParametersOutput struct{ *pulumi.OutputState } + +func (GetMariadbInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetMariadbInstanceParameters)(nil)).Elem() +} + +func (o GetMariadbInstanceParametersOutput) ToGetMariadbInstanceParametersOutput() GetMariadbInstanceParametersOutput { + return o +} + +func (o GetMariadbInstanceParametersOutput) ToGetMariadbInstanceParametersOutputWithContext(ctx context.Context) GetMariadbInstanceParametersOutput { + return o +} + +// Enable monitoring. +func (o GetMariadbInstanceParametersOutput) EnableMonitoring() pulumi.BoolOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) bool { return v.EnableMonitoring }).(pulumi.BoolOutput) +} + +func (o GetMariadbInstanceParametersOutput) Graphite() pulumi.StringOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) string { return v.Graphite }).(pulumi.StringOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o GetMariadbInstanceParametersOutput) MaxDiskThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) int { return v.MaxDiskThreshold }).(pulumi.IntOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o GetMariadbInstanceParametersOutput) MetricsFrequency() pulumi.IntOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) int { return v.MetricsFrequency }).(pulumi.IntOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o GetMariadbInstanceParametersOutput) MetricsPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) string { return v.MetricsPrefix }).(pulumi.StringOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o GetMariadbInstanceParametersOutput) MonitoringInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) string { return v.MonitoringInstanceId }).(pulumi.StringOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o GetMariadbInstanceParametersOutput) SgwAcl() pulumi.StringOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) string { return v.SgwAcl }).(pulumi.StringOutput) +} + +// List of syslog servers to send logs to. +func (o GetMariadbInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetMariadbInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +type GetMongodbflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description string `pulumi:"description"` + Id string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// GetMongodbflexInstanceFlavorInput is an input type that accepts GetMongodbflexInstanceFlavorArgs and GetMongodbflexInstanceFlavorOutput values. +// You can construct a concrete instance of `GetMongodbflexInstanceFlavorInput` via: +// +// GetMongodbflexInstanceFlavorArgs{...} +type GetMongodbflexInstanceFlavorInput interface { + pulumi.Input + + ToGetMongodbflexInstanceFlavorOutput() GetMongodbflexInstanceFlavorOutput + ToGetMongodbflexInstanceFlavorOutputWithContext(context.Context) GetMongodbflexInstanceFlavorOutput +} + +type GetMongodbflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringInput `pulumi:"description"` + Id pulumi.StringInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (GetMongodbflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceFlavor)(nil)).Elem() +} + +func (i GetMongodbflexInstanceFlavorArgs) ToGetMongodbflexInstanceFlavorOutput() GetMongodbflexInstanceFlavorOutput { + return i.ToGetMongodbflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i GetMongodbflexInstanceFlavorArgs) ToGetMongodbflexInstanceFlavorOutputWithContext(ctx context.Context) GetMongodbflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetMongodbflexInstanceFlavorOutput) +} + +type GetMongodbflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (GetMongodbflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceFlavor)(nil)).Elem() +} + +func (o GetMongodbflexInstanceFlavorOutput) ToGetMongodbflexInstanceFlavorOutput() GetMongodbflexInstanceFlavorOutput { + return o +} + +func (o GetMongodbflexInstanceFlavorOutput) ToGetMongodbflexInstanceFlavorOutputWithContext(ctx context.Context) GetMongodbflexInstanceFlavorOutput { + return o +} + +func (o GetMongodbflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o GetMongodbflexInstanceFlavorOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetMongodbflexInstanceFlavor) string { return v.Description }).(pulumi.StringOutput) +} + +func (o GetMongodbflexInstanceFlavorOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetMongodbflexInstanceFlavor) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetMongodbflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type GetMongodbflexInstanceOptions struct { + // The number of days that daily backups will be retained. + DailySnapshotRetentionDays int `pulumi:"dailySnapshotRetentionDays"` + // The number of months that monthly backups will be retained. + MonthlySnapshotRetentionMonths int `pulumi:"monthlySnapshotRetentionMonths"` + // The number of hours back in time the point-in-time recovery feature will be able to recover. + PointInTimeWindowHours int `pulumi:"pointInTimeWindowHours"` + // The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + SnapshotRetentionDays int `pulumi:"snapshotRetentionDays"` + // Type of the MongoDB Flex instance. + Type string `pulumi:"type"` + // The number of weeks that weekly backups will be retained. + WeeklySnapshotRetentionWeeks int `pulumi:"weeklySnapshotRetentionWeeks"` +} + +// GetMongodbflexInstanceOptionsInput is an input type that accepts GetMongodbflexInstanceOptionsArgs and GetMongodbflexInstanceOptionsOutput values. +// You can construct a concrete instance of `GetMongodbflexInstanceOptionsInput` via: +// +// GetMongodbflexInstanceOptionsArgs{...} +type GetMongodbflexInstanceOptionsInput interface { + pulumi.Input + + ToGetMongodbflexInstanceOptionsOutput() GetMongodbflexInstanceOptionsOutput + ToGetMongodbflexInstanceOptionsOutputWithContext(context.Context) GetMongodbflexInstanceOptionsOutput +} + +type GetMongodbflexInstanceOptionsArgs struct { + // The number of days that daily backups will be retained. + DailySnapshotRetentionDays pulumi.IntInput `pulumi:"dailySnapshotRetentionDays"` + // The number of months that monthly backups will be retained. + MonthlySnapshotRetentionMonths pulumi.IntInput `pulumi:"monthlySnapshotRetentionMonths"` + // The number of hours back in time the point-in-time recovery feature will be able to recover. + PointInTimeWindowHours pulumi.IntInput `pulumi:"pointInTimeWindowHours"` + // The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + SnapshotRetentionDays pulumi.IntInput `pulumi:"snapshotRetentionDays"` + // Type of the MongoDB Flex instance. + Type pulumi.StringInput `pulumi:"type"` + // The number of weeks that weekly backups will be retained. + WeeklySnapshotRetentionWeeks pulumi.IntInput `pulumi:"weeklySnapshotRetentionWeeks"` +} + +func (GetMongodbflexInstanceOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceOptions)(nil)).Elem() +} + +func (i GetMongodbflexInstanceOptionsArgs) ToGetMongodbflexInstanceOptionsOutput() GetMongodbflexInstanceOptionsOutput { + return i.ToGetMongodbflexInstanceOptionsOutputWithContext(context.Background()) +} + +func (i GetMongodbflexInstanceOptionsArgs) ToGetMongodbflexInstanceOptionsOutputWithContext(ctx context.Context) GetMongodbflexInstanceOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetMongodbflexInstanceOptionsOutput) +} + +type GetMongodbflexInstanceOptionsOutput struct{ *pulumi.OutputState } + +func (GetMongodbflexInstanceOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceOptions)(nil)).Elem() +} + +func (o GetMongodbflexInstanceOptionsOutput) ToGetMongodbflexInstanceOptionsOutput() GetMongodbflexInstanceOptionsOutput { + return o +} + +func (o GetMongodbflexInstanceOptionsOutput) ToGetMongodbflexInstanceOptionsOutputWithContext(ctx context.Context) GetMongodbflexInstanceOptionsOutput { + return o +} + +// The number of days that daily backups will be retained. +func (o GetMongodbflexInstanceOptionsOutput) DailySnapshotRetentionDays() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) int { return v.DailySnapshotRetentionDays }).(pulumi.IntOutput) +} + +// The number of months that monthly backups will be retained. +func (o GetMongodbflexInstanceOptionsOutput) MonthlySnapshotRetentionMonths() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) int { return v.MonthlySnapshotRetentionMonths }).(pulumi.IntOutput) +} + +// The number of hours back in time the point-in-time recovery feature will be able to recover. +func (o GetMongodbflexInstanceOptionsOutput) PointInTimeWindowHours() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) int { return v.PointInTimeWindowHours }).(pulumi.IntOutput) +} + +// The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. +func (o GetMongodbflexInstanceOptionsOutput) SnapshotRetentionDays() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) int { return v.SnapshotRetentionDays }).(pulumi.IntOutput) +} + +// Type of the MongoDB Flex instance. +func (o GetMongodbflexInstanceOptionsOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) string { return v.Type }).(pulumi.StringOutput) +} + +// The number of weeks that weekly backups will be retained. +func (o GetMongodbflexInstanceOptionsOutput) WeeklySnapshotRetentionWeeks() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceOptions) int { return v.WeeklySnapshotRetentionWeeks }).(pulumi.IntOutput) +} + +type GetMongodbflexInstanceStorage struct { + Class string `pulumi:"class"` + Size int `pulumi:"size"` +} + +// GetMongodbflexInstanceStorageInput is an input type that accepts GetMongodbflexInstanceStorageArgs and GetMongodbflexInstanceStorageOutput values. +// You can construct a concrete instance of `GetMongodbflexInstanceStorageInput` via: +// +// GetMongodbflexInstanceStorageArgs{...} +type GetMongodbflexInstanceStorageInput interface { + pulumi.Input + + ToGetMongodbflexInstanceStorageOutput() GetMongodbflexInstanceStorageOutput + ToGetMongodbflexInstanceStorageOutputWithContext(context.Context) GetMongodbflexInstanceStorageOutput +} + +type GetMongodbflexInstanceStorageArgs struct { + Class pulumi.StringInput `pulumi:"class"` + Size pulumi.IntInput `pulumi:"size"` +} + +func (GetMongodbflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceStorage)(nil)).Elem() +} + +func (i GetMongodbflexInstanceStorageArgs) ToGetMongodbflexInstanceStorageOutput() GetMongodbflexInstanceStorageOutput { + return i.ToGetMongodbflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i GetMongodbflexInstanceStorageArgs) ToGetMongodbflexInstanceStorageOutputWithContext(ctx context.Context) GetMongodbflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetMongodbflexInstanceStorageOutput) +} + +type GetMongodbflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (GetMongodbflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetMongodbflexInstanceStorage)(nil)).Elem() +} + +func (o GetMongodbflexInstanceStorageOutput) ToGetMongodbflexInstanceStorageOutput() GetMongodbflexInstanceStorageOutput { + return o +} + +func (o GetMongodbflexInstanceStorageOutput) ToGetMongodbflexInstanceStorageOutputWithContext(ctx context.Context) GetMongodbflexInstanceStorageOutput { + return o +} + +func (o GetMongodbflexInstanceStorageOutput) Class() pulumi.StringOutput { + return o.ApplyT(func(v GetMongodbflexInstanceStorage) string { return v.Class }).(pulumi.StringOutput) +} + +func (o GetMongodbflexInstanceStorageOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetMongodbflexInstanceStorage) int { return v.Size }).(pulumi.IntOutput) +} + +type GetNetworkAreaNetworkRange struct { + NetworkRangeId string `pulumi:"networkRangeId"` + Prefix string `pulumi:"prefix"` +} + +// GetNetworkAreaNetworkRangeInput is an input type that accepts GetNetworkAreaNetworkRangeArgs and GetNetworkAreaNetworkRangeOutput values. +// You can construct a concrete instance of `GetNetworkAreaNetworkRangeInput` via: +// +// GetNetworkAreaNetworkRangeArgs{...} +type GetNetworkAreaNetworkRangeInput interface { + pulumi.Input + + ToGetNetworkAreaNetworkRangeOutput() GetNetworkAreaNetworkRangeOutput + ToGetNetworkAreaNetworkRangeOutputWithContext(context.Context) GetNetworkAreaNetworkRangeOutput +} + +type GetNetworkAreaNetworkRangeArgs struct { + NetworkRangeId pulumi.StringInput `pulumi:"networkRangeId"` + Prefix pulumi.StringInput `pulumi:"prefix"` +} + +func (GetNetworkAreaNetworkRangeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetNetworkAreaNetworkRange)(nil)).Elem() +} + +func (i GetNetworkAreaNetworkRangeArgs) ToGetNetworkAreaNetworkRangeOutput() GetNetworkAreaNetworkRangeOutput { + return i.ToGetNetworkAreaNetworkRangeOutputWithContext(context.Background()) +} + +func (i GetNetworkAreaNetworkRangeArgs) ToGetNetworkAreaNetworkRangeOutputWithContext(ctx context.Context) GetNetworkAreaNetworkRangeOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetNetworkAreaNetworkRangeOutput) +} + +// GetNetworkAreaNetworkRangeArrayInput is an input type that accepts GetNetworkAreaNetworkRangeArray and GetNetworkAreaNetworkRangeArrayOutput values. +// You can construct a concrete instance of `GetNetworkAreaNetworkRangeArrayInput` via: +// +// GetNetworkAreaNetworkRangeArray{ GetNetworkAreaNetworkRangeArgs{...} } +type GetNetworkAreaNetworkRangeArrayInput interface { + pulumi.Input + + ToGetNetworkAreaNetworkRangeArrayOutput() GetNetworkAreaNetworkRangeArrayOutput + ToGetNetworkAreaNetworkRangeArrayOutputWithContext(context.Context) GetNetworkAreaNetworkRangeArrayOutput +} + +type GetNetworkAreaNetworkRangeArray []GetNetworkAreaNetworkRangeInput + +func (GetNetworkAreaNetworkRangeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetNetworkAreaNetworkRange)(nil)).Elem() +} + +func (i GetNetworkAreaNetworkRangeArray) ToGetNetworkAreaNetworkRangeArrayOutput() GetNetworkAreaNetworkRangeArrayOutput { + return i.ToGetNetworkAreaNetworkRangeArrayOutputWithContext(context.Background()) +} + +func (i GetNetworkAreaNetworkRangeArray) ToGetNetworkAreaNetworkRangeArrayOutputWithContext(ctx context.Context) GetNetworkAreaNetworkRangeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetNetworkAreaNetworkRangeArrayOutput) +} + +type GetNetworkAreaNetworkRangeOutput struct{ *pulumi.OutputState } + +func (GetNetworkAreaNetworkRangeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetNetworkAreaNetworkRange)(nil)).Elem() +} + +func (o GetNetworkAreaNetworkRangeOutput) ToGetNetworkAreaNetworkRangeOutput() GetNetworkAreaNetworkRangeOutput { + return o +} + +func (o GetNetworkAreaNetworkRangeOutput) ToGetNetworkAreaNetworkRangeOutputWithContext(ctx context.Context) GetNetworkAreaNetworkRangeOutput { + return o +} + +func (o GetNetworkAreaNetworkRangeOutput) NetworkRangeId() pulumi.StringOutput { + return o.ApplyT(func(v GetNetworkAreaNetworkRange) string { return v.NetworkRangeId }).(pulumi.StringOutput) +} + +func (o GetNetworkAreaNetworkRangeOutput) Prefix() pulumi.StringOutput { + return o.ApplyT(func(v GetNetworkAreaNetworkRange) string { return v.Prefix }).(pulumi.StringOutput) +} + +type GetNetworkAreaNetworkRangeArrayOutput struct{ *pulumi.OutputState } + +func (GetNetworkAreaNetworkRangeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetNetworkAreaNetworkRange)(nil)).Elem() +} + +func (o GetNetworkAreaNetworkRangeArrayOutput) ToGetNetworkAreaNetworkRangeArrayOutput() GetNetworkAreaNetworkRangeArrayOutput { + return o +} + +func (o GetNetworkAreaNetworkRangeArrayOutput) ToGetNetworkAreaNetworkRangeArrayOutputWithContext(ctx context.Context) GetNetworkAreaNetworkRangeArrayOutput { + return o +} + +func (o GetNetworkAreaNetworkRangeArrayOutput) Index(i pulumi.IntInput) GetNetworkAreaNetworkRangeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetNetworkAreaNetworkRange { + return vs[0].([]GetNetworkAreaNetworkRange)[vs[1].(int)] + }).(GetNetworkAreaNetworkRangeOutput) +} + +type GetObservabilityAlertgroupRule struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert string `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations map[string]string `pulumi:"annotations"` + // The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression string `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For string `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels map[string]string `pulumi:"labels"` +} + +// GetObservabilityAlertgroupRuleInput is an input type that accepts GetObservabilityAlertgroupRuleArgs and GetObservabilityAlertgroupRuleOutput values. +// You can construct a concrete instance of `GetObservabilityAlertgroupRuleInput` via: +// +// GetObservabilityAlertgroupRuleArgs{...} +type GetObservabilityAlertgroupRuleInput interface { + pulumi.Input + + ToGetObservabilityAlertgroupRuleOutput() GetObservabilityAlertgroupRuleOutput + ToGetObservabilityAlertgroupRuleOutputWithContext(context.Context) GetObservabilityAlertgroupRuleOutput +} + +type GetObservabilityAlertgroupRuleArgs struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert pulumi.StringInput `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression pulumi.StringInput `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For pulumi.StringInput `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (GetObservabilityAlertgroupRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityAlertgroupRule)(nil)).Elem() +} + +func (i GetObservabilityAlertgroupRuleArgs) ToGetObservabilityAlertgroupRuleOutput() GetObservabilityAlertgroupRuleOutput { + return i.ToGetObservabilityAlertgroupRuleOutputWithContext(context.Background()) +} + +func (i GetObservabilityAlertgroupRuleArgs) ToGetObservabilityAlertgroupRuleOutputWithContext(ctx context.Context) GetObservabilityAlertgroupRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityAlertgroupRuleOutput) +} + +// GetObservabilityAlertgroupRuleArrayInput is an input type that accepts GetObservabilityAlertgroupRuleArray and GetObservabilityAlertgroupRuleArrayOutput values. +// You can construct a concrete instance of `GetObservabilityAlertgroupRuleArrayInput` via: +// +// GetObservabilityAlertgroupRuleArray{ GetObservabilityAlertgroupRuleArgs{...} } +type GetObservabilityAlertgroupRuleArrayInput interface { + pulumi.Input + + ToGetObservabilityAlertgroupRuleArrayOutput() GetObservabilityAlertgroupRuleArrayOutput + ToGetObservabilityAlertgroupRuleArrayOutputWithContext(context.Context) GetObservabilityAlertgroupRuleArrayOutput +} + +type GetObservabilityAlertgroupRuleArray []GetObservabilityAlertgroupRuleInput + +func (GetObservabilityAlertgroupRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityAlertgroupRule)(nil)).Elem() +} + +func (i GetObservabilityAlertgroupRuleArray) ToGetObservabilityAlertgroupRuleArrayOutput() GetObservabilityAlertgroupRuleArrayOutput { + return i.ToGetObservabilityAlertgroupRuleArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityAlertgroupRuleArray) ToGetObservabilityAlertgroupRuleArrayOutputWithContext(ctx context.Context) GetObservabilityAlertgroupRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityAlertgroupRuleArrayOutput) +} + +type GetObservabilityAlertgroupRuleOutput struct{ *pulumi.OutputState } + +func (GetObservabilityAlertgroupRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityAlertgroupRule)(nil)).Elem() +} + +func (o GetObservabilityAlertgroupRuleOutput) ToGetObservabilityAlertgroupRuleOutput() GetObservabilityAlertgroupRuleOutput { + return o +} + +func (o GetObservabilityAlertgroupRuleOutput) ToGetObservabilityAlertgroupRuleOutputWithContext(ctx context.Context) GetObservabilityAlertgroupRuleOutput { + return o +} + +// The name of the alert rule. Is the identifier and must be unique in the group. +func (o GetObservabilityAlertgroupRuleOutput) Alert() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityAlertgroupRule) string { return v.Alert }).(pulumi.StringOutput) +} + +// A map of key:value. Annotations to add or overwrite for each alert +func (o GetObservabilityAlertgroupRuleOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityAlertgroupRule) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. +func (o GetObservabilityAlertgroupRuleOutput) Expression() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityAlertgroupRule) string { return v.Expression }).(pulumi.StringOutput) +} + +// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s +func (o GetObservabilityAlertgroupRuleOutput) For() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityAlertgroupRule) string { return v.For }).(pulumi.StringOutput) +} + +// A map of key:value. Labels to add or overwrite for each alert +func (o GetObservabilityAlertgroupRuleOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityAlertgroupRule) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type GetObservabilityAlertgroupRuleArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityAlertgroupRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityAlertgroupRule)(nil)).Elem() +} + +func (o GetObservabilityAlertgroupRuleArrayOutput) ToGetObservabilityAlertgroupRuleArrayOutput() GetObservabilityAlertgroupRuleArrayOutput { + return o +} + +func (o GetObservabilityAlertgroupRuleArrayOutput) ToGetObservabilityAlertgroupRuleArrayOutputWithContext(ctx context.Context) GetObservabilityAlertgroupRuleArrayOutput { + return o +} + +func (o GetObservabilityAlertgroupRuleArrayOutput) Index(i pulumi.IntInput) GetObservabilityAlertgroupRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityAlertgroupRule { + return vs[0].([]GetObservabilityAlertgroupRule)[vs[1].(int)] + }).(GetObservabilityAlertgroupRuleOutput) +} + +type GetObservabilityInstanceAlertConfig struct { + // Global configuration for the alerts. + Global GetObservabilityInstanceAlertConfigGlobal `pulumi:"global"` + // List of alert receivers. + Receivers []GetObservabilityInstanceAlertConfigReceiver `pulumi:"receivers"` + // The route for the alert. + Route GetObservabilityInstanceAlertConfigRoute `pulumi:"route"` +} + +// GetObservabilityInstanceAlertConfigInput is an input type that accepts GetObservabilityInstanceAlertConfigArgs and GetObservabilityInstanceAlertConfigOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigInput` via: +// +// GetObservabilityInstanceAlertConfigArgs{...} +type GetObservabilityInstanceAlertConfigInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigOutput() GetObservabilityInstanceAlertConfigOutput + ToGetObservabilityInstanceAlertConfigOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigOutput +} + +type GetObservabilityInstanceAlertConfigArgs struct { + // Global configuration for the alerts. + Global GetObservabilityInstanceAlertConfigGlobalInput `pulumi:"global"` + // List of alert receivers. + Receivers GetObservabilityInstanceAlertConfigReceiverArrayInput `pulumi:"receivers"` + // The route for the alert. + Route GetObservabilityInstanceAlertConfigRouteInput `pulumi:"route"` +} + +func (GetObservabilityInstanceAlertConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigArgs) ToGetObservabilityInstanceAlertConfigOutput() GetObservabilityInstanceAlertConfigOutput { + return i.ToGetObservabilityInstanceAlertConfigOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigArgs) ToGetObservabilityInstanceAlertConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigOutput) +} + +type GetObservabilityInstanceAlertConfigOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigOutput) ToGetObservabilityInstanceAlertConfigOutput() GetObservabilityInstanceAlertConfigOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigOutput) ToGetObservabilityInstanceAlertConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigOutput { + return o +} + +// Global configuration for the alerts. +func (o GetObservabilityInstanceAlertConfigOutput) Global() GetObservabilityInstanceAlertConfigGlobalOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfig) GetObservabilityInstanceAlertConfigGlobal { return v.Global }).(GetObservabilityInstanceAlertConfigGlobalOutput) +} + +// List of alert receivers. +func (o GetObservabilityInstanceAlertConfigOutput) Receivers() GetObservabilityInstanceAlertConfigReceiverArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfig) []GetObservabilityInstanceAlertConfigReceiver { + return v.Receivers + }).(GetObservabilityInstanceAlertConfigReceiverArrayOutput) +} + +// The route for the alert. +func (o GetObservabilityInstanceAlertConfigOutput) Route() GetObservabilityInstanceAlertConfigRouteOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfig) GetObservabilityInstanceAlertConfigRoute { return v.Route }).(GetObservabilityInstanceAlertConfigRouteOutput) +} + +type GetObservabilityInstanceAlertConfigGlobal struct { + // The API key for OpsGenie. + OpsgenieApiKey string `pulumi:"opsgenieApiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + OpsgenieApiUrl string `pulumi:"opsgenieApiUrl"` + // The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + ResolveTimeout string `pulumi:"resolveTimeout"` + // SMTP authentication information. Must be a valid email address + SmtpAuthIdentity string `pulumi:"smtpAuthIdentity"` + // SMTP Auth using LOGIN and PLAIN. + SmtpAuthPassword string `pulumi:"smtpAuthPassword"` + // SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + SmtpAuthUsername string `pulumi:"smtpAuthUsername"` + // The default SMTP From header field. Must be a valid email address + SmtpFrom string `pulumi:"smtpFrom"` + // The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + SmtpSmartHost string `pulumi:"smtpSmartHost"` +} + +// GetObservabilityInstanceAlertConfigGlobalInput is an input type that accepts GetObservabilityInstanceAlertConfigGlobalArgs and GetObservabilityInstanceAlertConfigGlobalOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigGlobalInput` via: +// +// GetObservabilityInstanceAlertConfigGlobalArgs{...} +type GetObservabilityInstanceAlertConfigGlobalInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigGlobalOutput() GetObservabilityInstanceAlertConfigGlobalOutput + ToGetObservabilityInstanceAlertConfigGlobalOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigGlobalOutput +} + +type GetObservabilityInstanceAlertConfigGlobalArgs struct { + // The API key for OpsGenie. + OpsgenieApiKey pulumi.StringInput `pulumi:"opsgenieApiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + OpsgenieApiUrl pulumi.StringInput `pulumi:"opsgenieApiUrl"` + // The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + ResolveTimeout pulumi.StringInput `pulumi:"resolveTimeout"` + // SMTP authentication information. Must be a valid email address + SmtpAuthIdentity pulumi.StringInput `pulumi:"smtpAuthIdentity"` + // SMTP Auth using LOGIN and PLAIN. + SmtpAuthPassword pulumi.StringInput `pulumi:"smtpAuthPassword"` + // SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + SmtpAuthUsername pulumi.StringInput `pulumi:"smtpAuthUsername"` + // The default SMTP From header field. Must be a valid email address + SmtpFrom pulumi.StringInput `pulumi:"smtpFrom"` + // The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + SmtpSmartHost pulumi.StringInput `pulumi:"smtpSmartHost"` +} + +func (GetObservabilityInstanceAlertConfigGlobalArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigGlobalArgs) ToGetObservabilityInstanceAlertConfigGlobalOutput() GetObservabilityInstanceAlertConfigGlobalOutput { + return i.ToGetObservabilityInstanceAlertConfigGlobalOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigGlobalArgs) ToGetObservabilityInstanceAlertConfigGlobalOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigGlobalOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigGlobalOutput) +} + +type GetObservabilityInstanceAlertConfigGlobalOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigGlobalOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigGlobal)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigGlobalOutput) ToGetObservabilityInstanceAlertConfigGlobalOutput() GetObservabilityInstanceAlertConfigGlobalOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigGlobalOutput) ToGetObservabilityInstanceAlertConfigGlobalOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigGlobalOutput { + return o +} + +// The API key for OpsGenie. +func (o GetObservabilityInstanceAlertConfigGlobalOutput) OpsgenieApiKey() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.OpsgenieApiKey }).(pulumi.StringOutput) +} + +// The host to send OpsGenie API requests to. Must be a valid URL +func (o GetObservabilityInstanceAlertConfigGlobalOutput) OpsgenieApiUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.OpsgenieApiUrl }).(pulumi.StringOutput) +} + +// The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. +func (o GetObservabilityInstanceAlertConfigGlobalOutput) ResolveTimeout() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.ResolveTimeout }).(pulumi.StringOutput) +} + +// SMTP authentication information. Must be a valid email address +func (o GetObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthIdentity() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.SmtpAuthIdentity }).(pulumi.StringOutput) +} + +// SMTP Auth using LOGIN and PLAIN. +func (o GetObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthPassword() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.SmtpAuthPassword }).(pulumi.StringOutput) +} + +// SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. +func (o GetObservabilityInstanceAlertConfigGlobalOutput) SmtpAuthUsername() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.SmtpAuthUsername }).(pulumi.StringOutput) +} + +// The default SMTP From header field. Must be a valid email address +func (o GetObservabilityInstanceAlertConfigGlobalOutput) SmtpFrom() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.SmtpFrom }).(pulumi.StringOutput) +} + +// The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). +func (o GetObservabilityInstanceAlertConfigGlobalOutput) SmtpSmartHost() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigGlobal) string { return v.SmtpSmartHost }).(pulumi.StringOutput) +} + +type GetObservabilityInstanceAlertConfigReceiver struct { + // List of email configurations. + EmailConfigs []GetObservabilityInstanceAlertConfigReceiverEmailConfig `pulumi:"emailConfigs"` + // Name of the receiver. + Name string `pulumi:"name"` + // List of OpsGenie configurations. + OpsgenieConfigs []GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig `pulumi:"opsgenieConfigs"` + // List of Webhooks configurations. + WebhooksConfigs []GetObservabilityInstanceAlertConfigReceiverWebhooksConfig `pulumi:"webhooksConfigs"` +} + +// GetObservabilityInstanceAlertConfigReceiverInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverArgs and GetObservabilityInstanceAlertConfigReceiverOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverArgs{...} +type GetObservabilityInstanceAlertConfigReceiverInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverOutput() GetObservabilityInstanceAlertConfigReceiverOutput + ToGetObservabilityInstanceAlertConfigReceiverOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverOutput +} + +type GetObservabilityInstanceAlertConfigReceiverArgs struct { + // List of email configurations. + EmailConfigs GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput `pulumi:"emailConfigs"` + // Name of the receiver. + Name pulumi.StringInput `pulumi:"name"` + // List of OpsGenie configurations. + OpsgenieConfigs GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput `pulumi:"opsgenieConfigs"` + // List of Webhooks configurations. + WebhooksConfigs GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput `pulumi:"webhooksConfigs"` +} + +func (GetObservabilityInstanceAlertConfigReceiverArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverArgs) ToGetObservabilityInstanceAlertConfigReceiverOutput() GetObservabilityInstanceAlertConfigReceiverOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverArgs) ToGetObservabilityInstanceAlertConfigReceiverOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverOutput) +} + +// GetObservabilityInstanceAlertConfigReceiverArrayInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverArray and GetObservabilityInstanceAlertConfigReceiverArrayOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverArrayInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverArray{ GetObservabilityInstanceAlertConfigReceiverArgs{...} } +type GetObservabilityInstanceAlertConfigReceiverArrayInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverArrayOutput() GetObservabilityInstanceAlertConfigReceiverArrayOutput + ToGetObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverArrayOutput +} + +type GetObservabilityInstanceAlertConfigReceiverArray []GetObservabilityInstanceAlertConfigReceiverInput + +func (GetObservabilityInstanceAlertConfigReceiverArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverArray) ToGetObservabilityInstanceAlertConfigReceiverArrayOutput() GetObservabilityInstanceAlertConfigReceiverArrayOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverArray) ToGetObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverArrayOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverOutput) ToGetObservabilityInstanceAlertConfigReceiverOutput() GetObservabilityInstanceAlertConfigReceiverOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverOutput) ToGetObservabilityInstanceAlertConfigReceiverOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOutput { + return o +} + +// List of email configurations. +func (o GetObservabilityInstanceAlertConfigReceiverOutput) EmailConfigs() GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiver) []GetObservabilityInstanceAlertConfigReceiverEmailConfig { + return v.EmailConfigs + }).(GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) +} + +// Name of the receiver. +func (o GetObservabilityInstanceAlertConfigReceiverOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiver) string { return v.Name }).(pulumi.StringOutput) +} + +// List of OpsGenie configurations. +func (o GetObservabilityInstanceAlertConfigReceiverOutput) OpsgenieConfigs() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiver) []GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + return v.OpsgenieConfigs + }).(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) +} + +// List of Webhooks configurations. +func (o GetObservabilityInstanceAlertConfigReceiverOutput) WebhooksConfigs() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiver) []GetObservabilityInstanceAlertConfigReceiverWebhooksConfig { + return v.WebhooksConfigs + }).(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiver)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverArrayOutput() GetObservabilityInstanceAlertConfigReceiverArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverArrayOutput) Index(i pulumi.IntInput) GetObservabilityInstanceAlertConfigReceiverOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityInstanceAlertConfigReceiver { + return vs[0].([]GetObservabilityInstanceAlertConfigReceiver)[vs[1].(int)] + }).(GetObservabilityInstanceAlertConfigReceiverOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverEmailConfig struct { + // SMTP authentication information. Must be a valid email address + AuthIdentity string `pulumi:"authIdentity"` + // SMTP authentication password. + AuthPassword string `pulumi:"authPassword"` + // SMTP authentication username. + AuthUsername string `pulumi:"authUsername"` + // The sender email address. Must be a valid email address + From string `pulumi:"from"` + // The SMTP host through which emails are sent. + SmartHost string `pulumi:"smartHost"` + // The email address to send notifications to. Must be a valid email address + To string `pulumi:"to"` +} + +// GetObservabilityInstanceAlertConfigReceiverEmailConfigInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs and GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverEmailConfigInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs{...} +type GetObservabilityInstanceAlertConfigReceiverEmailConfigInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput + ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput +} + +type GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs struct { + // SMTP authentication information. Must be a valid email address + AuthIdentity pulumi.StringInput `pulumi:"authIdentity"` + // SMTP authentication password. + AuthPassword pulumi.StringInput `pulumi:"authPassword"` + // SMTP authentication username. + AuthUsername pulumi.StringInput `pulumi:"authUsername"` + // The sender email address. Must be a valid email address + From pulumi.StringInput `pulumi:"from"` + // The SMTP host through which emails are sent. + SmartHost pulumi.StringInput `pulumi:"smartHost"` + // The email address to send notifications to. Must be a valid email address + To pulumi.StringInput `pulumi:"to"` +} + +func (GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) +} + +// GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverEmailConfigArray and GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverEmailConfigArray{ GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs{...} } +type GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput + ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput +} + +type GetObservabilityInstanceAlertConfigReceiverEmailConfigArray []GetObservabilityInstanceAlertConfigReceiverEmailConfigInput + +func (GetObservabilityInstanceAlertConfigReceiverEmailConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverEmailConfigArray) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverEmailConfigArray) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return o +} + +// SMTP authentication information. Must be a valid email address +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthIdentity() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.AuthIdentity }).(pulumi.StringOutput) +} + +// SMTP authentication password. +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthPassword() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.AuthPassword }).(pulumi.StringOutput) +} + +// SMTP authentication username. +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) AuthUsername() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.AuthUsername }).(pulumi.StringOutput) +} + +// The sender email address. Must be a valid email address +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) From() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.From }).(pulumi.StringOutput) +} + +// The SMTP host through which emails are sent. +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) SmartHost() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.SmartHost }).(pulumi.StringOutput) +} + +// The email address to send notifications to. Must be a valid email address +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) To() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverEmailConfig) string { return v.To }).(pulumi.StringOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverEmailConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput) Index(i pulumi.IntInput) GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityInstanceAlertConfigReceiverEmailConfig { + return vs[0].([]GetObservabilityInstanceAlertConfigReceiverEmailConfig)[vs[1].(int)] + }).(GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig struct { + // The API key for OpsGenie. + ApiKey string `pulumi:"apiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + ApiUrl string `pulumi:"apiUrl"` + // Comma separated list of tags attached to the notifications. + Tags string `pulumi:"tags"` +} + +// GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs and GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{...} +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput + ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput +} + +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs struct { + // The API key for OpsGenie. + ApiKey pulumi.StringInput `pulumi:"apiKey"` + // The host to send OpsGenie API requests to. Must be a valid URL + ApiUrl pulumi.StringInput `pulumi:"apiUrl"` + // Comma separated list of tags attached to the notifications. + Tags pulumi.StringInput `pulumi:"tags"` +} + +func (GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) +} + +// GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray and GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray{ GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{...} } +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput + ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput +} + +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray []GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput + +func (GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return o +} + +// The API key for OpsGenie. +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ApiKey() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig) string { return v.ApiKey }).(pulumi.StringOutput) +} + +// The host to send OpsGenie API requests to. Must be a valid URL +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) ApiUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig) string { return v.ApiUrl }).(pulumi.StringOutput) +} + +// Comma separated list of tags attached to the notifications. +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) Tags() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig) string { return v.Tags }).(pulumi.StringOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput) Index(i pulumi.IntInput) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + return vs[0].([]GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig)[vs[1].(int)] + }).(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfig struct { + // Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + MsTeams bool `pulumi:"msTeams"` + // The endpoint to send HTTP POST requests to. Must be a valid URL + Url string `pulumi:"url"` +} + +// GetObservabilityInstanceAlertConfigReceiverWebhooksConfigInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs and GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverWebhooksConfigInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{...} +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput + ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput +} + +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs struct { + // Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + MsTeams pulumi.BoolInput `pulumi:"msTeams"` + // The endpoint to send HTTP POST requests to. Must be a valid URL + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) +} + +// GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput is an input type that accepts GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray and GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput` via: +// +// GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray{ GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{...} } +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput + ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput +} + +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray []GetObservabilityInstanceAlertConfigReceiverWebhooksConfigInput + +func (GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return i.ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return o +} + +// Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) MsTeams() pulumi.BoolOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverWebhooksConfig) bool { return v.MsTeams }).(pulumi.BoolOutput) +} + +// The endpoint to send HTTP POST requests to. Must be a valid URL +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigReceiverWebhooksConfig) string { return v.Url }).(pulumi.StringOutput) +} + +type GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigReceiverWebhooksConfig)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput() GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) ToGetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput) Index(i pulumi.IntInput) GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityInstanceAlertConfigReceiverWebhooksConfig { + return vs[0].([]GetObservabilityInstanceAlertConfigReceiverWebhooksConfig)[vs[1].(int)] + }).(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput) +} + +type GetObservabilityInstanceAlertConfigRoute struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies []string `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval string `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + GroupWait string `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match map[string]string `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex map[string]string `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver string `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval string `pulumi:"repeatInterval"` + // List of child routes. + Routes []GetObservabilityInstanceAlertConfigRouteRoute `pulumi:"routes"` +} + +// GetObservabilityInstanceAlertConfigRouteInput is an input type that accepts GetObservabilityInstanceAlertConfigRouteArgs and GetObservabilityInstanceAlertConfigRouteOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigRouteInput` via: +// +// GetObservabilityInstanceAlertConfigRouteArgs{...} +type GetObservabilityInstanceAlertConfigRouteInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigRouteOutput() GetObservabilityInstanceAlertConfigRouteOutput + ToGetObservabilityInstanceAlertConfigRouteOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigRouteOutput +} + +type GetObservabilityInstanceAlertConfigRouteArgs struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies pulumi.StringArrayInput `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval pulumi.StringInput `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + GroupWait pulumi.StringInput `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match pulumi.StringMapInput `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex pulumi.StringMapInput `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver pulumi.StringInput `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval pulumi.StringInput `pulumi:"repeatInterval"` + // List of child routes. + Routes GetObservabilityInstanceAlertConfigRouteRouteArrayInput `pulumi:"routes"` +} + +func (GetObservabilityInstanceAlertConfigRouteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigRouteArgs) ToGetObservabilityInstanceAlertConfigRouteOutput() GetObservabilityInstanceAlertConfigRouteOutput { + return i.ToGetObservabilityInstanceAlertConfigRouteOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigRouteArgs) ToGetObservabilityInstanceAlertConfigRouteOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigRouteOutput) +} + +type GetObservabilityInstanceAlertConfigRouteOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigRouteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigRoute)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigRouteOutput) ToGetObservabilityInstanceAlertConfigRouteOutput() GetObservabilityInstanceAlertConfigRouteOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigRouteOutput) ToGetObservabilityInstanceAlertConfigRouteOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteOutput { + return o +} + +// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. +func (o GetObservabilityInstanceAlertConfigRouteOutput) GroupBies() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) []string { return v.GroupBies }).(pulumi.StringArrayOutput) +} + +// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) +func (o GetObservabilityInstanceAlertConfigRouteOutput) GroupInterval() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) string { return v.GroupInterval }).(pulumi.StringOutput) +} + +// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . +func (o GetObservabilityInstanceAlertConfigRouteOutput) GroupWait() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) string { return v.GroupWait }).(pulumi.StringOutput) +} + +// A set of equality matchers an alert has to fulfill to match the node. +func (o GetObservabilityInstanceAlertConfigRouteOutput) Match() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) map[string]string { return v.Match }).(pulumi.StringMapOutput) +} + +// A set of regex-matchers an alert has to fulfill to match the node. +func (o GetObservabilityInstanceAlertConfigRouteOutput) MatchRegex() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) map[string]string { return v.MatchRegex }).(pulumi.StringMapOutput) +} + +// The name of the receiver to route the alerts to. +func (o GetObservabilityInstanceAlertConfigRouteOutput) Receiver() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) string { return v.Receiver }).(pulumi.StringOutput) +} + +// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). +func (o GetObservabilityInstanceAlertConfigRouteOutput) RepeatInterval() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) string { return v.RepeatInterval }).(pulumi.StringOutput) +} + +// List of child routes. +func (o GetObservabilityInstanceAlertConfigRouteOutput) Routes() GetObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRoute) []GetObservabilityInstanceAlertConfigRouteRoute { + return v.Routes + }).(GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) +} + +type GetObservabilityInstanceAlertConfigRouteRoute struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies []string `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval string `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait string `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match map[string]string `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex map[string]string `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver string `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval string `pulumi:"repeatInterval"` +} + +// GetObservabilityInstanceAlertConfigRouteRouteInput is an input type that accepts GetObservabilityInstanceAlertConfigRouteRouteArgs and GetObservabilityInstanceAlertConfigRouteRouteOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigRouteRouteInput` via: +// +// GetObservabilityInstanceAlertConfigRouteRouteArgs{...} +type GetObservabilityInstanceAlertConfigRouteRouteInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigRouteRouteOutput() GetObservabilityInstanceAlertConfigRouteRouteOutput + ToGetObservabilityInstanceAlertConfigRouteRouteOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigRouteRouteOutput +} + +type GetObservabilityInstanceAlertConfigRouteRouteArgs struct { + // The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + GroupBies pulumi.StringArrayInput `pulumi:"groupBies"` + // How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + GroupInterval pulumi.StringInput `pulumi:"groupInterval"` + // How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + GroupWait pulumi.StringInput `pulumi:"groupWait"` + // A set of equality matchers an alert has to fulfill to match the node. + Match pulumi.StringMapInput `pulumi:"match"` + // A set of regex-matchers an alert has to fulfill to match the node. + MatchRegex pulumi.StringMapInput `pulumi:"matchRegex"` + // The name of the receiver to route the alerts to. + Receiver pulumi.StringInput `pulumi:"receiver"` + // How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + RepeatInterval pulumi.StringInput `pulumi:"repeatInterval"` +} + +func (GetObservabilityInstanceAlertConfigRouteRouteArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigRouteRouteArgs) ToGetObservabilityInstanceAlertConfigRouteRouteOutput() GetObservabilityInstanceAlertConfigRouteRouteOutput { + return i.ToGetObservabilityInstanceAlertConfigRouteRouteOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigRouteRouteArgs) ToGetObservabilityInstanceAlertConfigRouteRouteOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteRouteOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigRouteRouteOutput) +} + +// GetObservabilityInstanceAlertConfigRouteRouteArrayInput is an input type that accepts GetObservabilityInstanceAlertConfigRouteRouteArray and GetObservabilityInstanceAlertConfigRouteRouteArrayOutput values. +// You can construct a concrete instance of `GetObservabilityInstanceAlertConfigRouteRouteArrayInput` via: +// +// GetObservabilityInstanceAlertConfigRouteRouteArray{ GetObservabilityInstanceAlertConfigRouteRouteArgs{...} } +type GetObservabilityInstanceAlertConfigRouteRouteArrayInput interface { + pulumi.Input + + ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutput() GetObservabilityInstanceAlertConfigRouteRouteArrayOutput + ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(context.Context) GetObservabilityInstanceAlertConfigRouteRouteArrayOutput +} + +type GetObservabilityInstanceAlertConfigRouteRouteArray []GetObservabilityInstanceAlertConfigRouteRouteInput + +func (GetObservabilityInstanceAlertConfigRouteRouteArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (i GetObservabilityInstanceAlertConfigRouteRouteArray) ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutput() GetObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return i.ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityInstanceAlertConfigRouteRouteArray) ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) +} + +type GetObservabilityInstanceAlertConfigRouteRouteOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigRouteRouteOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) ToGetObservabilityInstanceAlertConfigRouteRouteOutput() GetObservabilityInstanceAlertConfigRouteRouteOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) ToGetObservabilityInstanceAlertConfigRouteRouteOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteRouteOutput { + return o +} + +// The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) GroupBies() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) []string { return v.GroupBies }).(pulumi.StringArrayOutput) +} + +// How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) GroupInterval() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) string { return v.GroupInterval }).(pulumi.StringOutput) +} + +// How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) GroupWait() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) string { return v.GroupWait }).(pulumi.StringOutput) +} + +// A set of equality matchers an alert has to fulfill to match the node. +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) Match() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) map[string]string { return v.Match }).(pulumi.StringMapOutput) +} + +// A set of regex-matchers an alert has to fulfill to match the node. +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) MatchRegex() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) map[string]string { return v.MatchRegex }).(pulumi.StringMapOutput) +} + +// The name of the receiver to route the alerts to. +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) Receiver() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) string { return v.Receiver }).(pulumi.StringOutput) +} + +// How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). +func (o GetObservabilityInstanceAlertConfigRouteRouteOutput) RepeatInterval() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityInstanceAlertConfigRouteRoute) string { return v.RepeatInterval }).(pulumi.StringOutput) +} + +type GetObservabilityInstanceAlertConfigRouteRouteArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityInstanceAlertConfigRouteRoute)(nil)).Elem() +} + +func (o GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutput() GetObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) ToGetObservabilityInstanceAlertConfigRouteRouteArrayOutputWithContext(ctx context.Context) GetObservabilityInstanceAlertConfigRouteRouteArrayOutput { + return o +} + +func (o GetObservabilityInstanceAlertConfigRouteRouteArrayOutput) Index(i pulumi.IntInput) GetObservabilityInstanceAlertConfigRouteRouteOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityInstanceAlertConfigRouteRoute { + return vs[0].([]GetObservabilityInstanceAlertConfigRouteRoute)[vs[1].(int)] + }).(GetObservabilityInstanceAlertConfigRouteRouteOutput) +} + +type GetObservabilityLogalertgroupRule struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert string `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations map[string]string `pulumi:"annotations"` + // The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression string `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For string `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels map[string]string `pulumi:"labels"` +} + +// GetObservabilityLogalertgroupRuleInput is an input type that accepts GetObservabilityLogalertgroupRuleArgs and GetObservabilityLogalertgroupRuleOutput values. +// You can construct a concrete instance of `GetObservabilityLogalertgroupRuleInput` via: +// +// GetObservabilityLogalertgroupRuleArgs{...} +type GetObservabilityLogalertgroupRuleInput interface { + pulumi.Input + + ToGetObservabilityLogalertgroupRuleOutput() GetObservabilityLogalertgroupRuleOutput + ToGetObservabilityLogalertgroupRuleOutputWithContext(context.Context) GetObservabilityLogalertgroupRuleOutput +} + +type GetObservabilityLogalertgroupRuleArgs struct { + // The name of the alert rule. Is the identifier and must be unique in the group. + Alert pulumi.StringInput `pulumi:"alert"` + // A map of key:value. Annotations to add or overwrite for each alert + Annotations pulumi.StringMapInput `pulumi:"annotations"` + // The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + Expression pulumi.StringInput `pulumi:"expression"` + // Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + For pulumi.StringInput `pulumi:"for"` + // A map of key:value. Labels to add or overwrite for each alert + Labels pulumi.StringMapInput `pulumi:"labels"` +} + +func (GetObservabilityLogalertgroupRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (i GetObservabilityLogalertgroupRuleArgs) ToGetObservabilityLogalertgroupRuleOutput() GetObservabilityLogalertgroupRuleOutput { + return i.ToGetObservabilityLogalertgroupRuleOutputWithContext(context.Background()) +} + +func (i GetObservabilityLogalertgroupRuleArgs) ToGetObservabilityLogalertgroupRuleOutputWithContext(ctx context.Context) GetObservabilityLogalertgroupRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityLogalertgroupRuleOutput) +} + +// GetObservabilityLogalertgroupRuleArrayInput is an input type that accepts GetObservabilityLogalertgroupRuleArray and GetObservabilityLogalertgroupRuleArrayOutput values. +// You can construct a concrete instance of `GetObservabilityLogalertgroupRuleArrayInput` via: +// +// GetObservabilityLogalertgroupRuleArray{ GetObservabilityLogalertgroupRuleArgs{...} } +type GetObservabilityLogalertgroupRuleArrayInput interface { + pulumi.Input + + ToGetObservabilityLogalertgroupRuleArrayOutput() GetObservabilityLogalertgroupRuleArrayOutput + ToGetObservabilityLogalertgroupRuleArrayOutputWithContext(context.Context) GetObservabilityLogalertgroupRuleArrayOutput +} + +type GetObservabilityLogalertgroupRuleArray []GetObservabilityLogalertgroupRuleInput + +func (GetObservabilityLogalertgroupRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (i GetObservabilityLogalertgroupRuleArray) ToGetObservabilityLogalertgroupRuleArrayOutput() GetObservabilityLogalertgroupRuleArrayOutput { + return i.ToGetObservabilityLogalertgroupRuleArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityLogalertgroupRuleArray) ToGetObservabilityLogalertgroupRuleArrayOutputWithContext(ctx context.Context) GetObservabilityLogalertgroupRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityLogalertgroupRuleArrayOutput) +} + +type GetObservabilityLogalertgroupRuleOutput struct{ *pulumi.OutputState } + +func (GetObservabilityLogalertgroupRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (o GetObservabilityLogalertgroupRuleOutput) ToGetObservabilityLogalertgroupRuleOutput() GetObservabilityLogalertgroupRuleOutput { + return o +} + +func (o GetObservabilityLogalertgroupRuleOutput) ToGetObservabilityLogalertgroupRuleOutputWithContext(ctx context.Context) GetObservabilityLogalertgroupRuleOutput { + return o +} + +// The name of the alert rule. Is the identifier and must be unique in the group. +func (o GetObservabilityLogalertgroupRuleOutput) Alert() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityLogalertgroupRule) string { return v.Alert }).(pulumi.StringOutput) +} + +// A map of key:value. Annotations to add or overwrite for each alert +func (o GetObservabilityLogalertgroupRuleOutput) Annotations() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityLogalertgroupRule) map[string]string { return v.Annotations }).(pulumi.StringMapOutput) +} + +// The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. +func (o GetObservabilityLogalertgroupRuleOutput) Expression() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityLogalertgroupRule) string { return v.Expression }).(pulumi.StringOutput) +} + +// Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s +func (o GetObservabilityLogalertgroupRuleOutput) For() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityLogalertgroupRule) string { return v.For }).(pulumi.StringOutput) +} + +// A map of key:value. Labels to add or overwrite for each alert +func (o GetObservabilityLogalertgroupRuleOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityLogalertgroupRule) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +type GetObservabilityLogalertgroupRuleArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityLogalertgroupRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityLogalertgroupRule)(nil)).Elem() +} + +func (o GetObservabilityLogalertgroupRuleArrayOutput) ToGetObservabilityLogalertgroupRuleArrayOutput() GetObservabilityLogalertgroupRuleArrayOutput { + return o +} + +func (o GetObservabilityLogalertgroupRuleArrayOutput) ToGetObservabilityLogalertgroupRuleArrayOutputWithContext(ctx context.Context) GetObservabilityLogalertgroupRuleArrayOutput { + return o +} + +func (o GetObservabilityLogalertgroupRuleArrayOutput) Index(i pulumi.IntInput) GetObservabilityLogalertgroupRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityLogalertgroupRule { + return vs[0].([]GetObservabilityLogalertgroupRule)[vs[1].(int)] + }).(GetObservabilityLogalertgroupRuleOutput) +} + +type GetObservabilityScrapeconfigBasicAuth struct { + // Specifies basic auth password. + Password string `pulumi:"password"` + // Specifies basic auth username. + Username string `pulumi:"username"` +} + +// GetObservabilityScrapeconfigBasicAuthInput is an input type that accepts GetObservabilityScrapeconfigBasicAuthArgs and GetObservabilityScrapeconfigBasicAuthOutput values. +// You can construct a concrete instance of `GetObservabilityScrapeconfigBasicAuthInput` via: +// +// GetObservabilityScrapeconfigBasicAuthArgs{...} +type GetObservabilityScrapeconfigBasicAuthInput interface { + pulumi.Input + + ToGetObservabilityScrapeconfigBasicAuthOutput() GetObservabilityScrapeconfigBasicAuthOutput + ToGetObservabilityScrapeconfigBasicAuthOutputWithContext(context.Context) GetObservabilityScrapeconfigBasicAuthOutput +} + +type GetObservabilityScrapeconfigBasicAuthArgs struct { + // Specifies basic auth password. + Password pulumi.StringInput `pulumi:"password"` + // Specifies basic auth username. + Username pulumi.StringInput `pulumi:"username"` +} + +func (GetObservabilityScrapeconfigBasicAuthArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (i GetObservabilityScrapeconfigBasicAuthArgs) ToGetObservabilityScrapeconfigBasicAuthOutput() GetObservabilityScrapeconfigBasicAuthOutput { + return i.ToGetObservabilityScrapeconfigBasicAuthOutputWithContext(context.Background()) +} + +func (i GetObservabilityScrapeconfigBasicAuthArgs) ToGetObservabilityScrapeconfigBasicAuthOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigBasicAuthOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityScrapeconfigBasicAuthOutput) +} + +type GetObservabilityScrapeconfigBasicAuthOutput struct{ *pulumi.OutputState } + +func (GetObservabilityScrapeconfigBasicAuthOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigBasicAuth)(nil)).Elem() +} + +func (o GetObservabilityScrapeconfigBasicAuthOutput) ToGetObservabilityScrapeconfigBasicAuthOutput() GetObservabilityScrapeconfigBasicAuthOutput { + return o +} + +func (o GetObservabilityScrapeconfigBasicAuthOutput) ToGetObservabilityScrapeconfigBasicAuthOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigBasicAuthOutput { + return o +} + +// Specifies basic auth password. +func (o GetObservabilityScrapeconfigBasicAuthOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityScrapeconfigBasicAuth) string { return v.Password }).(pulumi.StringOutput) +} + +// Specifies basic auth username. +func (o GetObservabilityScrapeconfigBasicAuthOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v GetObservabilityScrapeconfigBasicAuth) string { return v.Username }).(pulumi.StringOutput) +} + +type GetObservabilityScrapeconfigSaml2 struct { + // Specifies if URL parameters are enabled + EnableUrlParameters bool `pulumi:"enableUrlParameters"` +} + +// GetObservabilityScrapeconfigSaml2Input is an input type that accepts GetObservabilityScrapeconfigSaml2Args and GetObservabilityScrapeconfigSaml2Output values. +// You can construct a concrete instance of `GetObservabilityScrapeconfigSaml2Input` via: +// +// GetObservabilityScrapeconfigSaml2Args{...} +type GetObservabilityScrapeconfigSaml2Input interface { + pulumi.Input + + ToGetObservabilityScrapeconfigSaml2Output() GetObservabilityScrapeconfigSaml2Output + ToGetObservabilityScrapeconfigSaml2OutputWithContext(context.Context) GetObservabilityScrapeconfigSaml2Output +} + +type GetObservabilityScrapeconfigSaml2Args struct { + // Specifies if URL parameters are enabled + EnableUrlParameters pulumi.BoolInput `pulumi:"enableUrlParameters"` +} + +func (GetObservabilityScrapeconfigSaml2Args) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (i GetObservabilityScrapeconfigSaml2Args) ToGetObservabilityScrapeconfigSaml2Output() GetObservabilityScrapeconfigSaml2Output { + return i.ToGetObservabilityScrapeconfigSaml2OutputWithContext(context.Background()) +} + +func (i GetObservabilityScrapeconfigSaml2Args) ToGetObservabilityScrapeconfigSaml2OutputWithContext(ctx context.Context) GetObservabilityScrapeconfigSaml2Output { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityScrapeconfigSaml2Output) +} + +type GetObservabilityScrapeconfigSaml2Output struct{ *pulumi.OutputState } + +func (GetObservabilityScrapeconfigSaml2Output) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigSaml2)(nil)).Elem() +} + +func (o GetObservabilityScrapeconfigSaml2Output) ToGetObservabilityScrapeconfigSaml2Output() GetObservabilityScrapeconfigSaml2Output { + return o +} + +func (o GetObservabilityScrapeconfigSaml2Output) ToGetObservabilityScrapeconfigSaml2OutputWithContext(ctx context.Context) GetObservabilityScrapeconfigSaml2Output { + return o +} + +// Specifies if URL parameters are enabled +func (o GetObservabilityScrapeconfigSaml2Output) EnableUrlParameters() pulumi.BoolOutput { + return o.ApplyT(func(v GetObservabilityScrapeconfigSaml2) bool { return v.EnableUrlParameters }).(pulumi.BoolOutput) +} + +type GetObservabilityScrapeconfigTarget struct { + // Specifies labels. + Labels map[string]string `pulumi:"labels"` + // Specifies target URLs. + Urls []string `pulumi:"urls"` +} + +// GetObservabilityScrapeconfigTargetInput is an input type that accepts GetObservabilityScrapeconfigTargetArgs and GetObservabilityScrapeconfigTargetOutput values. +// You can construct a concrete instance of `GetObservabilityScrapeconfigTargetInput` via: +// +// GetObservabilityScrapeconfigTargetArgs{...} +type GetObservabilityScrapeconfigTargetInput interface { + pulumi.Input + + ToGetObservabilityScrapeconfigTargetOutput() GetObservabilityScrapeconfigTargetOutput + ToGetObservabilityScrapeconfigTargetOutputWithContext(context.Context) GetObservabilityScrapeconfigTargetOutput +} + +type GetObservabilityScrapeconfigTargetArgs struct { + // Specifies labels. + Labels pulumi.StringMapInput `pulumi:"labels"` + // Specifies target URLs. + Urls pulumi.StringArrayInput `pulumi:"urls"` +} + +func (GetObservabilityScrapeconfigTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (i GetObservabilityScrapeconfigTargetArgs) ToGetObservabilityScrapeconfigTargetOutput() GetObservabilityScrapeconfigTargetOutput { + return i.ToGetObservabilityScrapeconfigTargetOutputWithContext(context.Background()) +} + +func (i GetObservabilityScrapeconfigTargetArgs) ToGetObservabilityScrapeconfigTargetOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityScrapeconfigTargetOutput) +} + +// GetObservabilityScrapeconfigTargetArrayInput is an input type that accepts GetObservabilityScrapeconfigTargetArray and GetObservabilityScrapeconfigTargetArrayOutput values. +// You can construct a concrete instance of `GetObservabilityScrapeconfigTargetArrayInput` via: +// +// GetObservabilityScrapeconfigTargetArray{ GetObservabilityScrapeconfigTargetArgs{...} } +type GetObservabilityScrapeconfigTargetArrayInput interface { + pulumi.Input + + ToGetObservabilityScrapeconfigTargetArrayOutput() GetObservabilityScrapeconfigTargetArrayOutput + ToGetObservabilityScrapeconfigTargetArrayOutputWithContext(context.Context) GetObservabilityScrapeconfigTargetArrayOutput +} + +type GetObservabilityScrapeconfigTargetArray []GetObservabilityScrapeconfigTargetInput + +func (GetObservabilityScrapeconfigTargetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (i GetObservabilityScrapeconfigTargetArray) ToGetObservabilityScrapeconfigTargetArrayOutput() GetObservabilityScrapeconfigTargetArrayOutput { + return i.ToGetObservabilityScrapeconfigTargetArrayOutputWithContext(context.Background()) +} + +func (i GetObservabilityScrapeconfigTargetArray) ToGetObservabilityScrapeconfigTargetArrayOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigTargetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetObservabilityScrapeconfigTargetArrayOutput) +} + +type GetObservabilityScrapeconfigTargetOutput struct{ *pulumi.OutputState } + +func (GetObservabilityScrapeconfigTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (o GetObservabilityScrapeconfigTargetOutput) ToGetObservabilityScrapeconfigTargetOutput() GetObservabilityScrapeconfigTargetOutput { + return o +} + +func (o GetObservabilityScrapeconfigTargetOutput) ToGetObservabilityScrapeconfigTargetOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigTargetOutput { + return o +} + +// Specifies labels. +func (o GetObservabilityScrapeconfigTargetOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v GetObservabilityScrapeconfigTarget) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// Specifies target URLs. +func (o GetObservabilityScrapeconfigTargetOutput) Urls() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetObservabilityScrapeconfigTarget) []string { return v.Urls }).(pulumi.StringArrayOutput) +} + +type GetObservabilityScrapeconfigTargetArrayOutput struct{ *pulumi.OutputState } + +func (GetObservabilityScrapeconfigTargetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetObservabilityScrapeconfigTarget)(nil)).Elem() +} + +func (o GetObservabilityScrapeconfigTargetArrayOutput) ToGetObservabilityScrapeconfigTargetArrayOutput() GetObservabilityScrapeconfigTargetArrayOutput { + return o +} + +func (o GetObservabilityScrapeconfigTargetArrayOutput) ToGetObservabilityScrapeconfigTargetArrayOutputWithContext(ctx context.Context) GetObservabilityScrapeconfigTargetArrayOutput { + return o +} + +func (o GetObservabilityScrapeconfigTargetArrayOutput) Index(i pulumi.IntInput) GetObservabilityScrapeconfigTargetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetObservabilityScrapeconfigTarget { + return vs[0].([]GetObservabilityScrapeconfigTarget)[vs[1].(int)] + }).(GetObservabilityScrapeconfigTargetOutput) +} + +type GetOpensearchInstanceParameters struct { + // Enable monitoring. + EnableMonitoring bool `pulumi:"enableMonitoring"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite string `pulumi:"graphite"` + // The garbage collector to use for OpenSearch. + JavaGarbageCollector string `pulumi:"javaGarbageCollector"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace int `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace int `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId string `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + Plugins []string `pulumi:"plugins"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // The TLS protocol to use. + TlsProtocols string `pulumi:"tlsProtocols"` +} + +// GetOpensearchInstanceParametersInput is an input type that accepts GetOpensearchInstanceParametersArgs and GetOpensearchInstanceParametersOutput values. +// You can construct a concrete instance of `GetOpensearchInstanceParametersInput` via: +// +// GetOpensearchInstanceParametersArgs{...} +type GetOpensearchInstanceParametersInput interface { + pulumi.Input + + ToGetOpensearchInstanceParametersOutput() GetOpensearchInstanceParametersOutput + ToGetOpensearchInstanceParametersOutputWithContext(context.Context) GetOpensearchInstanceParametersOutput +} + +type GetOpensearchInstanceParametersArgs struct { + // Enable monitoring. + EnableMonitoring pulumi.BoolInput `pulumi:"enableMonitoring"` + // If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + Graphite pulumi.StringInput `pulumi:"graphite"` + // The garbage collector to use for OpenSearch. + JavaGarbageCollector pulumi.StringInput `pulumi:"javaGarbageCollector"` + // The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + JavaHeapspace pulumi.IntInput `pulumi:"javaHeapspace"` + // The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + JavaMaxmetaspace pulumi.IntInput `pulumi:"javaMaxmetaspace"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted (in seconds). + MetricsFrequency pulumi.IntInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + MetricsPrefix pulumi.StringInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringInput `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + Plugins pulumi.StringArrayInput `pulumi:"plugins"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // The TLS protocol to use. + TlsProtocols pulumi.StringInput `pulumi:"tlsProtocols"` +} + +func (GetOpensearchInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOpensearchInstanceParameters)(nil)).Elem() +} + +func (i GetOpensearchInstanceParametersArgs) ToGetOpensearchInstanceParametersOutput() GetOpensearchInstanceParametersOutput { + return i.ToGetOpensearchInstanceParametersOutputWithContext(context.Background()) +} + +func (i GetOpensearchInstanceParametersArgs) ToGetOpensearchInstanceParametersOutputWithContext(ctx context.Context) GetOpensearchInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOpensearchInstanceParametersOutput) +} + +type GetOpensearchInstanceParametersOutput struct{ *pulumi.OutputState } + +func (GetOpensearchInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOpensearchInstanceParameters)(nil)).Elem() +} + +func (o GetOpensearchInstanceParametersOutput) ToGetOpensearchInstanceParametersOutput() GetOpensearchInstanceParametersOutput { + return o +} + +func (o GetOpensearchInstanceParametersOutput) ToGetOpensearchInstanceParametersOutputWithContext(ctx context.Context) GetOpensearchInstanceParametersOutput { + return o +} + +// Enable monitoring. +func (o GetOpensearchInstanceParametersOutput) EnableMonitoring() pulumi.BoolOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) bool { return v.EnableMonitoring }).(pulumi.BoolOutput) +} + +// If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). +func (o GetOpensearchInstanceParametersOutput) Graphite() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.Graphite }).(pulumi.StringOutput) +} + +// The garbage collector to use for OpenSearch. +func (o GetOpensearchInstanceParametersOutput) JavaGarbageCollector() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.JavaGarbageCollector }).(pulumi.StringOutput) +} + +// The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. +func (o GetOpensearchInstanceParametersOutput) JavaHeapspace() pulumi.IntOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) int { return v.JavaHeapspace }).(pulumi.IntOutput) +} + +// The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. +func (o GetOpensearchInstanceParametersOutput) JavaMaxmetaspace() pulumi.IntOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) int { return v.JavaMaxmetaspace }).(pulumi.IntOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o GetOpensearchInstanceParametersOutput) MaxDiskThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) int { return v.MaxDiskThreshold }).(pulumi.IntOutput) +} + +// The frequency in seconds at which metrics are emitted (in seconds). +func (o GetOpensearchInstanceParametersOutput) MetricsFrequency() pulumi.IntOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) int { return v.MetricsFrequency }).(pulumi.IntOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. +func (o GetOpensearchInstanceParametersOutput) MetricsPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.MetricsPrefix }).(pulumi.StringOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o GetOpensearchInstanceParametersOutput) MonitoringInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.MonitoringInstanceId }).(pulumi.StringOutput) +} + +// List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. +func (o GetOpensearchInstanceParametersOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) []string { return v.Plugins }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o GetOpensearchInstanceParametersOutput) SgwAcl() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.SgwAcl }).(pulumi.StringOutput) +} + +// List of syslog servers to send logs to. +func (o GetOpensearchInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o GetOpensearchInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// The TLS protocol to use. +func (o GetOpensearchInstanceParametersOutput) TlsProtocols() pulumi.StringOutput { + return o.ApplyT(func(v GetOpensearchInstanceParameters) string { return v.TlsProtocols }).(pulumi.StringOutput) +} + +type GetPostgresflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description string `pulumi:"description"` + Id string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// GetPostgresflexInstanceFlavorInput is an input type that accepts GetPostgresflexInstanceFlavorArgs and GetPostgresflexInstanceFlavorOutput values. +// You can construct a concrete instance of `GetPostgresflexInstanceFlavorInput` via: +// +// GetPostgresflexInstanceFlavorArgs{...} +type GetPostgresflexInstanceFlavorInput interface { + pulumi.Input + + ToGetPostgresflexInstanceFlavorOutput() GetPostgresflexInstanceFlavorOutput + ToGetPostgresflexInstanceFlavorOutputWithContext(context.Context) GetPostgresflexInstanceFlavorOutput +} + +type GetPostgresflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringInput `pulumi:"description"` + Id pulumi.StringInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (GetPostgresflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetPostgresflexInstanceFlavor)(nil)).Elem() +} + +func (i GetPostgresflexInstanceFlavorArgs) ToGetPostgresflexInstanceFlavorOutput() GetPostgresflexInstanceFlavorOutput { + return i.ToGetPostgresflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i GetPostgresflexInstanceFlavorArgs) ToGetPostgresflexInstanceFlavorOutputWithContext(ctx context.Context) GetPostgresflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPostgresflexInstanceFlavorOutput) +} + +type GetPostgresflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (GetPostgresflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetPostgresflexInstanceFlavor)(nil)).Elem() +} + +func (o GetPostgresflexInstanceFlavorOutput) ToGetPostgresflexInstanceFlavorOutput() GetPostgresflexInstanceFlavorOutput { + return o +} + +func (o GetPostgresflexInstanceFlavorOutput) ToGetPostgresflexInstanceFlavorOutputWithContext(ctx context.Context) GetPostgresflexInstanceFlavorOutput { + return o +} + +func (o GetPostgresflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v GetPostgresflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o GetPostgresflexInstanceFlavorOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetPostgresflexInstanceFlavor) string { return v.Description }).(pulumi.StringOutput) +} + +func (o GetPostgresflexInstanceFlavorOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetPostgresflexInstanceFlavor) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetPostgresflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v GetPostgresflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type GetPostgresflexInstanceStorage struct { + Class string `pulumi:"class"` + Size int `pulumi:"size"` +} + +// GetPostgresflexInstanceStorageInput is an input type that accepts GetPostgresflexInstanceStorageArgs and GetPostgresflexInstanceStorageOutput values. +// You can construct a concrete instance of `GetPostgresflexInstanceStorageInput` via: +// +// GetPostgresflexInstanceStorageArgs{...} +type GetPostgresflexInstanceStorageInput interface { + pulumi.Input + + ToGetPostgresflexInstanceStorageOutput() GetPostgresflexInstanceStorageOutput + ToGetPostgresflexInstanceStorageOutputWithContext(context.Context) GetPostgresflexInstanceStorageOutput +} + +type GetPostgresflexInstanceStorageArgs struct { + Class pulumi.StringInput `pulumi:"class"` + Size pulumi.IntInput `pulumi:"size"` +} + +func (GetPostgresflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetPostgresflexInstanceStorage)(nil)).Elem() +} + +func (i GetPostgresflexInstanceStorageArgs) ToGetPostgresflexInstanceStorageOutput() GetPostgresflexInstanceStorageOutput { + return i.ToGetPostgresflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i GetPostgresflexInstanceStorageArgs) ToGetPostgresflexInstanceStorageOutputWithContext(ctx context.Context) GetPostgresflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPostgresflexInstanceStorageOutput) +} + +type GetPostgresflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (GetPostgresflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetPostgresflexInstanceStorage)(nil)).Elem() +} + +func (o GetPostgresflexInstanceStorageOutput) ToGetPostgresflexInstanceStorageOutput() GetPostgresflexInstanceStorageOutput { + return o +} + +func (o GetPostgresflexInstanceStorageOutput) ToGetPostgresflexInstanceStorageOutputWithContext(ctx context.Context) GetPostgresflexInstanceStorageOutput { + return o +} + +func (o GetPostgresflexInstanceStorageOutput) Class() pulumi.StringOutput { + return o.ApplyT(func(v GetPostgresflexInstanceStorage) string { return v.Class }).(pulumi.StringOutput) +} + +func (o GetPostgresflexInstanceStorageOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetPostgresflexInstanceStorage) int { return v.Size }).(pulumi.IntOutput) +} + +type GetPublicIpRangesPublicIpRange struct { + // Classless Inter-Domain Routing (CIDR) + Cidr string `pulumi:"cidr"` +} + +// GetPublicIpRangesPublicIpRangeInput is an input type that accepts GetPublicIpRangesPublicIpRangeArgs and GetPublicIpRangesPublicIpRangeOutput values. +// You can construct a concrete instance of `GetPublicIpRangesPublicIpRangeInput` via: +// +// GetPublicIpRangesPublicIpRangeArgs{...} +type GetPublicIpRangesPublicIpRangeInput interface { + pulumi.Input + + ToGetPublicIpRangesPublicIpRangeOutput() GetPublicIpRangesPublicIpRangeOutput + ToGetPublicIpRangesPublicIpRangeOutputWithContext(context.Context) GetPublicIpRangesPublicIpRangeOutput +} + +type GetPublicIpRangesPublicIpRangeArgs struct { + // Classless Inter-Domain Routing (CIDR) + Cidr pulumi.StringInput `pulumi:"cidr"` +} + +func (GetPublicIpRangesPublicIpRangeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetPublicIpRangesPublicIpRange)(nil)).Elem() +} + +func (i GetPublicIpRangesPublicIpRangeArgs) ToGetPublicIpRangesPublicIpRangeOutput() GetPublicIpRangesPublicIpRangeOutput { + return i.ToGetPublicIpRangesPublicIpRangeOutputWithContext(context.Background()) +} + +func (i GetPublicIpRangesPublicIpRangeArgs) ToGetPublicIpRangesPublicIpRangeOutputWithContext(ctx context.Context) GetPublicIpRangesPublicIpRangeOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPublicIpRangesPublicIpRangeOutput) +} + +// GetPublicIpRangesPublicIpRangeArrayInput is an input type that accepts GetPublicIpRangesPublicIpRangeArray and GetPublicIpRangesPublicIpRangeArrayOutput values. +// You can construct a concrete instance of `GetPublicIpRangesPublicIpRangeArrayInput` via: +// +// GetPublicIpRangesPublicIpRangeArray{ GetPublicIpRangesPublicIpRangeArgs{...} } +type GetPublicIpRangesPublicIpRangeArrayInput interface { + pulumi.Input + + ToGetPublicIpRangesPublicIpRangeArrayOutput() GetPublicIpRangesPublicIpRangeArrayOutput + ToGetPublicIpRangesPublicIpRangeArrayOutputWithContext(context.Context) GetPublicIpRangesPublicIpRangeArrayOutput +} + +type GetPublicIpRangesPublicIpRangeArray []GetPublicIpRangesPublicIpRangeInput + +func (GetPublicIpRangesPublicIpRangeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetPublicIpRangesPublicIpRange)(nil)).Elem() +} + +func (i GetPublicIpRangesPublicIpRangeArray) ToGetPublicIpRangesPublicIpRangeArrayOutput() GetPublicIpRangesPublicIpRangeArrayOutput { + return i.ToGetPublicIpRangesPublicIpRangeArrayOutputWithContext(context.Background()) +} + +func (i GetPublicIpRangesPublicIpRangeArray) ToGetPublicIpRangesPublicIpRangeArrayOutputWithContext(ctx context.Context) GetPublicIpRangesPublicIpRangeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetPublicIpRangesPublicIpRangeArrayOutput) +} + +type GetPublicIpRangesPublicIpRangeOutput struct{ *pulumi.OutputState } + +func (GetPublicIpRangesPublicIpRangeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetPublicIpRangesPublicIpRange)(nil)).Elem() +} + +func (o GetPublicIpRangesPublicIpRangeOutput) ToGetPublicIpRangesPublicIpRangeOutput() GetPublicIpRangesPublicIpRangeOutput { + return o +} + +func (o GetPublicIpRangesPublicIpRangeOutput) ToGetPublicIpRangesPublicIpRangeOutputWithContext(ctx context.Context) GetPublicIpRangesPublicIpRangeOutput { + return o +} + +// Classless Inter-Domain Routing (CIDR) +func (o GetPublicIpRangesPublicIpRangeOutput) Cidr() pulumi.StringOutput { + return o.ApplyT(func(v GetPublicIpRangesPublicIpRange) string { return v.Cidr }).(pulumi.StringOutput) +} + +type GetPublicIpRangesPublicIpRangeArrayOutput struct{ *pulumi.OutputState } + +func (GetPublicIpRangesPublicIpRangeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetPublicIpRangesPublicIpRange)(nil)).Elem() +} + +func (o GetPublicIpRangesPublicIpRangeArrayOutput) ToGetPublicIpRangesPublicIpRangeArrayOutput() GetPublicIpRangesPublicIpRangeArrayOutput { + return o +} + +func (o GetPublicIpRangesPublicIpRangeArrayOutput) ToGetPublicIpRangesPublicIpRangeArrayOutputWithContext(ctx context.Context) GetPublicIpRangesPublicIpRangeArrayOutput { + return o +} + +func (o GetPublicIpRangesPublicIpRangeArrayOutput) Index(i pulumi.IntInput) GetPublicIpRangesPublicIpRangeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPublicIpRangesPublicIpRange { + return vs[0].([]GetPublicIpRangesPublicIpRange)[vs[1].(int)] + }).(GetPublicIpRangesPublicIpRangeOutput) +} + +type GetRabbitmqInstanceParameters struct { + // The timeout in milliseconds for the consumer. + ConsumerTimeout int `pulumi:"consumerTimeout"` + // Enable monitoring. + EnableMonitoring bool `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite string `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold int `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix string `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId string `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. + Plugins []string `pulumi:"plugins"` + // List of roles to assign to the instance. + Roles []string `pulumi:"roles"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl string `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // TLS protocol to use. + TlsProtocols string `pulumi:"tlsProtocols"` +} + +// GetRabbitmqInstanceParametersInput is an input type that accepts GetRabbitmqInstanceParametersArgs and GetRabbitmqInstanceParametersOutput values. +// You can construct a concrete instance of `GetRabbitmqInstanceParametersInput` via: +// +// GetRabbitmqInstanceParametersArgs{...} +type GetRabbitmqInstanceParametersInput interface { + pulumi.Input + + ToGetRabbitmqInstanceParametersOutput() GetRabbitmqInstanceParametersOutput + ToGetRabbitmqInstanceParametersOutputWithContext(context.Context) GetRabbitmqInstanceParametersOutput +} + +type GetRabbitmqInstanceParametersArgs struct { + // The timeout in milliseconds for the consumer. + ConsumerTimeout pulumi.IntInput `pulumi:"consumerTimeout"` + // Enable monitoring. + EnableMonitoring pulumi.BoolInput `pulumi:"enableMonitoring"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite pulumi.StringInput `pulumi:"graphite"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntInput `pulumi:"maxDiskThreshold"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringInput `pulumi:"metricsPrefix"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringInput `pulumi:"monitoringInstanceId"` + // List of plugins to install. Must be a supported plugin name. + Plugins pulumi.StringArrayInput `pulumi:"plugins"` + // List of roles to assign to the instance. + Roles pulumi.StringArrayInput `pulumi:"roles"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringInput `pulumi:"sgwAcl"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // TLS protocol to use. + TlsProtocols pulumi.StringInput `pulumi:"tlsProtocols"` +} + +func (GetRabbitmqInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRabbitmqInstanceParameters)(nil)).Elem() +} + +func (i GetRabbitmqInstanceParametersArgs) ToGetRabbitmqInstanceParametersOutput() GetRabbitmqInstanceParametersOutput { + return i.ToGetRabbitmqInstanceParametersOutputWithContext(context.Background()) +} + +func (i GetRabbitmqInstanceParametersArgs) ToGetRabbitmqInstanceParametersOutputWithContext(ctx context.Context) GetRabbitmqInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRabbitmqInstanceParametersOutput) +} + +type GetRabbitmqInstanceParametersOutput struct{ *pulumi.OutputState } + +func (GetRabbitmqInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRabbitmqInstanceParameters)(nil)).Elem() +} + +func (o GetRabbitmqInstanceParametersOutput) ToGetRabbitmqInstanceParametersOutput() GetRabbitmqInstanceParametersOutput { + return o +} + +func (o GetRabbitmqInstanceParametersOutput) ToGetRabbitmqInstanceParametersOutputWithContext(ctx context.Context) GetRabbitmqInstanceParametersOutput { + return o +} + +// The timeout in milliseconds for the consumer. +func (o GetRabbitmqInstanceParametersOutput) ConsumerTimeout() pulumi.IntOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) int { return v.ConsumerTimeout }).(pulumi.IntOutput) +} + +// Enable monitoring. +func (o GetRabbitmqInstanceParametersOutput) EnableMonitoring() pulumi.BoolOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) bool { return v.EnableMonitoring }).(pulumi.BoolOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o GetRabbitmqInstanceParametersOutput) Graphite() pulumi.StringOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) string { return v.Graphite }).(pulumi.StringOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o GetRabbitmqInstanceParametersOutput) MaxDiskThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) int { return v.MaxDiskThreshold }).(pulumi.IntOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o GetRabbitmqInstanceParametersOutput) MetricsFrequency() pulumi.IntOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) int { return v.MetricsFrequency }).(pulumi.IntOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o GetRabbitmqInstanceParametersOutput) MetricsPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) string { return v.MetricsPrefix }).(pulumi.StringOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o GetRabbitmqInstanceParametersOutput) MonitoringInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) string { return v.MonitoringInstanceId }).(pulumi.StringOutput) +} + +// List of plugins to install. Must be a supported plugin name. +func (o GetRabbitmqInstanceParametersOutput) Plugins() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) []string { return v.Plugins }).(pulumi.StringArrayOutput) +} + +// List of roles to assign to the instance. +func (o GetRabbitmqInstanceParametersOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) []string { return v.Roles }).(pulumi.StringArrayOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o GetRabbitmqInstanceParametersOutput) SgwAcl() pulumi.StringOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) string { return v.SgwAcl }).(pulumi.StringOutput) +} + +// List of syslog servers to send logs to. +func (o GetRabbitmqInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o GetRabbitmqInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// TLS protocol to use. +func (o GetRabbitmqInstanceParametersOutput) TlsProtocols() pulumi.StringOutput { + return o.ApplyT(func(v GetRabbitmqInstanceParameters) string { return v.TlsProtocols }).(pulumi.StringOutput) +} + +type GetRedisInstanceParameters struct { + // The number of milliseconds after which the instance is considered down. + DownAfterMilliseconds int `pulumi:"downAfterMilliseconds"` + // Enable monitoring. + EnableMonitoring bool `pulumi:"enableMonitoring"` + // The failover timeout in milliseconds. + FailoverTimeout int `pulumi:"failoverTimeout"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite string `pulumi:"graphite"` + // The lazy eviction enablement (yes or no). + LazyfreeLazyEviction string `pulumi:"lazyfreeLazyEviction"` + // The lazy expire enablement (yes or no). + LazyfreeLazyExpire string `pulumi:"lazyfreeLazyExpire"` + // The Lua time limit. + LuaTimeLimit int `pulumi:"luaTimeLimit"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold int `pulumi:"maxDiskThreshold"` + // The maximum number of clients. + Maxclients int `pulumi:"maxclients"` + // The policy to handle the maximum memory (volatile-lru, noeviction, etc). + MaxmemoryPolicy string `pulumi:"maxmemoryPolicy"` + // The maximum memory samples. + MaxmemorySamples int `pulumi:"maxmemorySamples"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency int `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix string `pulumi:"metricsPrefix"` + // The minimum replicas maximum lag. + MinReplicasMaxLag int `pulumi:"minReplicasMaxLag"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId string `pulumi:"monitoringInstanceId"` + // The notify keyspace events. + NotifyKeyspaceEvents string `pulumi:"notifyKeyspaceEvents"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl string `pulumi:"sgwAcl"` + // The snapshot configuration. + Snapshot string `pulumi:"snapshot"` + // List of syslog servers to send logs to. + Syslogs []string `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers []string `pulumi:"tlsCiphers"` + // TLS cipher suites to use. + TlsCiphersuites string `pulumi:"tlsCiphersuites"` + // TLS protocol to use. + TlsProtocols string `pulumi:"tlsProtocols"` +} + +// GetRedisInstanceParametersInput is an input type that accepts GetRedisInstanceParametersArgs and GetRedisInstanceParametersOutput values. +// You can construct a concrete instance of `GetRedisInstanceParametersInput` via: +// +// GetRedisInstanceParametersArgs{...} +type GetRedisInstanceParametersInput interface { + pulumi.Input + + ToGetRedisInstanceParametersOutput() GetRedisInstanceParametersOutput + ToGetRedisInstanceParametersOutputWithContext(context.Context) GetRedisInstanceParametersOutput +} + +type GetRedisInstanceParametersArgs struct { + // The number of milliseconds after which the instance is considered down. + DownAfterMilliseconds pulumi.IntInput `pulumi:"downAfterMilliseconds"` + // Enable monitoring. + EnableMonitoring pulumi.BoolInput `pulumi:"enableMonitoring"` + // The failover timeout in milliseconds. + FailoverTimeout pulumi.IntInput `pulumi:"failoverTimeout"` + // Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + Graphite pulumi.StringInput `pulumi:"graphite"` + // The lazy eviction enablement (yes or no). + LazyfreeLazyEviction pulumi.StringInput `pulumi:"lazyfreeLazyEviction"` + // The lazy expire enablement (yes or no). + LazyfreeLazyExpire pulumi.StringInput `pulumi:"lazyfreeLazyExpire"` + // The Lua time limit. + LuaTimeLimit pulumi.IntInput `pulumi:"luaTimeLimit"` + // The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + MaxDiskThreshold pulumi.IntInput `pulumi:"maxDiskThreshold"` + // The maximum number of clients. + Maxclients pulumi.IntInput `pulumi:"maxclients"` + // The policy to handle the maximum memory (volatile-lru, noeviction, etc). + MaxmemoryPolicy pulumi.StringInput `pulumi:"maxmemoryPolicy"` + // The maximum memory samples. + MaxmemorySamples pulumi.IntInput `pulumi:"maxmemorySamples"` + // The frequency in seconds at which metrics are emitted. + MetricsFrequency pulumi.IntInput `pulumi:"metricsFrequency"` + // The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + MetricsPrefix pulumi.StringInput `pulumi:"metricsPrefix"` + // The minimum replicas maximum lag. + MinReplicasMaxLag pulumi.IntInput `pulumi:"minReplicasMaxLag"` + // The ID of the STACKIT monitoring instance. + MonitoringInstanceId pulumi.StringInput `pulumi:"monitoringInstanceId"` + // The notify keyspace events. + NotifyKeyspaceEvents pulumi.StringInput `pulumi:"notifyKeyspaceEvents"` + // Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + SgwAcl pulumi.StringInput `pulumi:"sgwAcl"` + // The snapshot configuration. + Snapshot pulumi.StringInput `pulumi:"snapshot"` + // List of syslog servers to send logs to. + Syslogs pulumi.StringArrayInput `pulumi:"syslogs"` + // List of TLS ciphers to use. + TlsCiphers pulumi.StringArrayInput `pulumi:"tlsCiphers"` + // TLS cipher suites to use. + TlsCiphersuites pulumi.StringInput `pulumi:"tlsCiphersuites"` + // TLS protocol to use. + TlsProtocols pulumi.StringInput `pulumi:"tlsProtocols"` +} + +func (GetRedisInstanceParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRedisInstanceParameters)(nil)).Elem() +} + +func (i GetRedisInstanceParametersArgs) ToGetRedisInstanceParametersOutput() GetRedisInstanceParametersOutput { + return i.ToGetRedisInstanceParametersOutputWithContext(context.Background()) +} + +func (i GetRedisInstanceParametersArgs) ToGetRedisInstanceParametersOutputWithContext(ctx context.Context) GetRedisInstanceParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRedisInstanceParametersOutput) +} + +type GetRedisInstanceParametersOutput struct{ *pulumi.OutputState } + +func (GetRedisInstanceParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRedisInstanceParameters)(nil)).Elem() +} + +func (o GetRedisInstanceParametersOutput) ToGetRedisInstanceParametersOutput() GetRedisInstanceParametersOutput { + return o +} + +func (o GetRedisInstanceParametersOutput) ToGetRedisInstanceParametersOutputWithContext(ctx context.Context) GetRedisInstanceParametersOutput { + return o +} + +// The number of milliseconds after which the instance is considered down. +func (o GetRedisInstanceParametersOutput) DownAfterMilliseconds() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.DownAfterMilliseconds }).(pulumi.IntOutput) +} + +// Enable monitoring. +func (o GetRedisInstanceParametersOutput) EnableMonitoring() pulumi.BoolOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) bool { return v.EnableMonitoring }).(pulumi.BoolOutput) +} + +// The failover timeout in milliseconds. +func (o GetRedisInstanceParametersOutput) FailoverTimeout() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.FailoverTimeout }).(pulumi.IntOutput) +} + +// Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. +func (o GetRedisInstanceParametersOutput) Graphite() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.Graphite }).(pulumi.StringOutput) +} + +// The lazy eviction enablement (yes or no). +func (o GetRedisInstanceParametersOutput) LazyfreeLazyEviction() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.LazyfreeLazyEviction }).(pulumi.StringOutput) +} + +// The lazy expire enablement (yes or no). +func (o GetRedisInstanceParametersOutput) LazyfreeLazyExpire() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.LazyfreeLazyExpire }).(pulumi.StringOutput) +} + +// The Lua time limit. +func (o GetRedisInstanceParametersOutput) LuaTimeLimit() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.LuaTimeLimit }).(pulumi.IntOutput) +} + +// The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. +func (o GetRedisInstanceParametersOutput) MaxDiskThreshold() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.MaxDiskThreshold }).(pulumi.IntOutput) +} + +// The maximum number of clients. +func (o GetRedisInstanceParametersOutput) Maxclients() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.Maxclients }).(pulumi.IntOutput) +} + +// The policy to handle the maximum memory (volatile-lru, noeviction, etc). +func (o GetRedisInstanceParametersOutput) MaxmemoryPolicy() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.MaxmemoryPolicy }).(pulumi.StringOutput) +} + +// The maximum memory samples. +func (o GetRedisInstanceParametersOutput) MaxmemorySamples() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.MaxmemorySamples }).(pulumi.IntOutput) +} + +// The frequency in seconds at which metrics are emitted. +func (o GetRedisInstanceParametersOutput) MetricsFrequency() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.MetricsFrequency }).(pulumi.IntOutput) +} + +// The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key +func (o GetRedisInstanceParametersOutput) MetricsPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.MetricsPrefix }).(pulumi.StringOutput) +} + +// The minimum replicas maximum lag. +func (o GetRedisInstanceParametersOutput) MinReplicasMaxLag() pulumi.IntOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) int { return v.MinReplicasMaxLag }).(pulumi.IntOutput) +} + +// The ID of the STACKIT monitoring instance. +func (o GetRedisInstanceParametersOutput) MonitoringInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.MonitoringInstanceId }).(pulumi.StringOutput) +} + +// The notify keyspace events. +func (o GetRedisInstanceParametersOutput) NotifyKeyspaceEvents() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.NotifyKeyspaceEvents }).(pulumi.StringOutput) +} + +// Comma separated list of IP networks in CIDR notation which are allowed to access this instance. +func (o GetRedisInstanceParametersOutput) SgwAcl() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.SgwAcl }).(pulumi.StringOutput) +} + +// The snapshot configuration. +func (o GetRedisInstanceParametersOutput) Snapshot() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.Snapshot }).(pulumi.StringOutput) +} + +// List of syslog servers to send logs to. +func (o GetRedisInstanceParametersOutput) Syslogs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) []string { return v.Syslogs }).(pulumi.StringArrayOutput) +} + +// List of TLS ciphers to use. +func (o GetRedisInstanceParametersOutput) TlsCiphers() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) []string { return v.TlsCiphers }).(pulumi.StringArrayOutput) +} + +// TLS cipher suites to use. +func (o GetRedisInstanceParametersOutput) TlsCiphersuites() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.TlsCiphersuites }).(pulumi.StringOutput) +} + +// TLS protocol to use. +func (o GetRedisInstanceParametersOutput) TlsProtocols() pulumi.StringOutput { + return o.ApplyT(func(v GetRedisInstanceParameters) string { return v.TlsProtocols }).(pulumi.StringOutput) +} + +type GetSecurityGroupRuleIcmpParameters struct { + // ICMP code. Can be set if the protocol is ICMP. + Code int `pulumi:"code"` + // ICMP type. Can be set if the protocol is ICMP. + Type int `pulumi:"type"` +} + +// GetSecurityGroupRuleIcmpParametersInput is an input type that accepts GetSecurityGroupRuleIcmpParametersArgs and GetSecurityGroupRuleIcmpParametersOutput values. +// You can construct a concrete instance of `GetSecurityGroupRuleIcmpParametersInput` via: +// +// GetSecurityGroupRuleIcmpParametersArgs{...} +type GetSecurityGroupRuleIcmpParametersInput interface { + pulumi.Input + + ToGetSecurityGroupRuleIcmpParametersOutput() GetSecurityGroupRuleIcmpParametersOutput + ToGetSecurityGroupRuleIcmpParametersOutputWithContext(context.Context) GetSecurityGroupRuleIcmpParametersOutput +} + +type GetSecurityGroupRuleIcmpParametersArgs struct { + // ICMP code. Can be set if the protocol is ICMP. + Code pulumi.IntInput `pulumi:"code"` + // ICMP type. Can be set if the protocol is ICMP. + Type pulumi.IntInput `pulumi:"type"` +} + +func (GetSecurityGroupRuleIcmpParametersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (i GetSecurityGroupRuleIcmpParametersArgs) ToGetSecurityGroupRuleIcmpParametersOutput() GetSecurityGroupRuleIcmpParametersOutput { + return i.ToGetSecurityGroupRuleIcmpParametersOutputWithContext(context.Background()) +} + +func (i GetSecurityGroupRuleIcmpParametersArgs) ToGetSecurityGroupRuleIcmpParametersOutputWithContext(ctx context.Context) GetSecurityGroupRuleIcmpParametersOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSecurityGroupRuleIcmpParametersOutput) +} + +type GetSecurityGroupRuleIcmpParametersOutput struct{ *pulumi.OutputState } + +func (GetSecurityGroupRuleIcmpParametersOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRuleIcmpParameters)(nil)).Elem() +} + +func (o GetSecurityGroupRuleIcmpParametersOutput) ToGetSecurityGroupRuleIcmpParametersOutput() GetSecurityGroupRuleIcmpParametersOutput { + return o +} + +func (o GetSecurityGroupRuleIcmpParametersOutput) ToGetSecurityGroupRuleIcmpParametersOutputWithContext(ctx context.Context) GetSecurityGroupRuleIcmpParametersOutput { + return o +} + +// ICMP code. Can be set if the protocol is ICMP. +func (o GetSecurityGroupRuleIcmpParametersOutput) Code() pulumi.IntOutput { + return o.ApplyT(func(v GetSecurityGroupRuleIcmpParameters) int { return v.Code }).(pulumi.IntOutput) +} + +// ICMP type. Can be set if the protocol is ICMP. +func (o GetSecurityGroupRuleIcmpParametersOutput) Type() pulumi.IntOutput { + return o.ApplyT(func(v GetSecurityGroupRuleIcmpParameters) int { return v.Type }).(pulumi.IntOutput) +} + +type GetSecurityGroupRulePortRange struct { + // The maximum port number. Should be greater or equal to the minimum. + Max int `pulumi:"max"` + // The minimum port number. Should be less or equal to the minimum. + Min int `pulumi:"min"` +} + +// GetSecurityGroupRulePortRangeInput is an input type that accepts GetSecurityGroupRulePortRangeArgs and GetSecurityGroupRulePortRangeOutput values. +// You can construct a concrete instance of `GetSecurityGroupRulePortRangeInput` via: +// +// GetSecurityGroupRulePortRangeArgs{...} +type GetSecurityGroupRulePortRangeInput interface { + pulumi.Input + + ToGetSecurityGroupRulePortRangeOutput() GetSecurityGroupRulePortRangeOutput + ToGetSecurityGroupRulePortRangeOutputWithContext(context.Context) GetSecurityGroupRulePortRangeOutput +} + +type GetSecurityGroupRulePortRangeArgs struct { + // The maximum port number. Should be greater or equal to the minimum. + Max pulumi.IntInput `pulumi:"max"` + // The minimum port number. Should be less or equal to the minimum. + Min pulumi.IntInput `pulumi:"min"` +} + +func (GetSecurityGroupRulePortRangeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRulePortRange)(nil)).Elem() +} + +func (i GetSecurityGroupRulePortRangeArgs) ToGetSecurityGroupRulePortRangeOutput() GetSecurityGroupRulePortRangeOutput { + return i.ToGetSecurityGroupRulePortRangeOutputWithContext(context.Background()) +} + +func (i GetSecurityGroupRulePortRangeArgs) ToGetSecurityGroupRulePortRangeOutputWithContext(ctx context.Context) GetSecurityGroupRulePortRangeOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSecurityGroupRulePortRangeOutput) +} + +type GetSecurityGroupRulePortRangeOutput struct{ *pulumi.OutputState } + +func (GetSecurityGroupRulePortRangeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRulePortRange)(nil)).Elem() +} + +func (o GetSecurityGroupRulePortRangeOutput) ToGetSecurityGroupRulePortRangeOutput() GetSecurityGroupRulePortRangeOutput { + return o +} + +func (o GetSecurityGroupRulePortRangeOutput) ToGetSecurityGroupRulePortRangeOutputWithContext(ctx context.Context) GetSecurityGroupRulePortRangeOutput { + return o +} + +// The maximum port number. Should be greater or equal to the minimum. +func (o GetSecurityGroupRulePortRangeOutput) Max() pulumi.IntOutput { + return o.ApplyT(func(v GetSecurityGroupRulePortRange) int { return v.Max }).(pulumi.IntOutput) +} + +// The minimum port number. Should be less or equal to the minimum. +func (o GetSecurityGroupRulePortRangeOutput) Min() pulumi.IntOutput { + return o.ApplyT(func(v GetSecurityGroupRulePortRange) int { return v.Min }).(pulumi.IntOutput) +} + +type GetSecurityGroupRuleProtocol struct { + // The protocol name which the rule should match. + Name string `pulumi:"name"` + // The protocol number which the rule should match. + Number int `pulumi:"number"` +} + +// GetSecurityGroupRuleProtocolInput is an input type that accepts GetSecurityGroupRuleProtocolArgs and GetSecurityGroupRuleProtocolOutput values. +// You can construct a concrete instance of `GetSecurityGroupRuleProtocolInput` via: +// +// GetSecurityGroupRuleProtocolArgs{...} +type GetSecurityGroupRuleProtocolInput interface { + pulumi.Input + + ToGetSecurityGroupRuleProtocolOutput() GetSecurityGroupRuleProtocolOutput + ToGetSecurityGroupRuleProtocolOutputWithContext(context.Context) GetSecurityGroupRuleProtocolOutput +} + +type GetSecurityGroupRuleProtocolArgs struct { + // The protocol name which the rule should match. + Name pulumi.StringInput `pulumi:"name"` + // The protocol number which the rule should match. + Number pulumi.IntInput `pulumi:"number"` +} + +func (GetSecurityGroupRuleProtocolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRuleProtocol)(nil)).Elem() +} + +func (i GetSecurityGroupRuleProtocolArgs) ToGetSecurityGroupRuleProtocolOutput() GetSecurityGroupRuleProtocolOutput { + return i.ToGetSecurityGroupRuleProtocolOutputWithContext(context.Background()) +} + +func (i GetSecurityGroupRuleProtocolArgs) ToGetSecurityGroupRuleProtocolOutputWithContext(ctx context.Context) GetSecurityGroupRuleProtocolOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSecurityGroupRuleProtocolOutput) +} + +type GetSecurityGroupRuleProtocolOutput struct{ *pulumi.OutputState } + +func (GetSecurityGroupRuleProtocolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSecurityGroupRuleProtocol)(nil)).Elem() +} + +func (o GetSecurityGroupRuleProtocolOutput) ToGetSecurityGroupRuleProtocolOutput() GetSecurityGroupRuleProtocolOutput { + return o +} + +func (o GetSecurityGroupRuleProtocolOutput) ToGetSecurityGroupRuleProtocolOutputWithContext(ctx context.Context) GetSecurityGroupRuleProtocolOutput { + return o +} + +// The protocol name which the rule should match. +func (o GetSecurityGroupRuleProtocolOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetSecurityGroupRuleProtocol) string { return v.Name }).(pulumi.StringOutput) +} + +// The protocol number which the rule should match. +func (o GetSecurityGroupRuleProtocolOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v GetSecurityGroupRuleProtocol) int { return v.Number }).(pulumi.IntOutput) +} + +type GetServerBackupScheduleBackupProperties struct { + Name string `pulumi:"name"` + RetentionPeriod int `pulumi:"retentionPeriod"` + VolumeIds []string `pulumi:"volumeIds"` +} + +// GetServerBackupScheduleBackupPropertiesInput is an input type that accepts GetServerBackupScheduleBackupPropertiesArgs and GetServerBackupScheduleBackupPropertiesOutput values. +// You can construct a concrete instance of `GetServerBackupScheduleBackupPropertiesInput` via: +// +// GetServerBackupScheduleBackupPropertiesArgs{...} +type GetServerBackupScheduleBackupPropertiesInput interface { + pulumi.Input + + ToGetServerBackupScheduleBackupPropertiesOutput() GetServerBackupScheduleBackupPropertiesOutput + ToGetServerBackupScheduleBackupPropertiesOutputWithContext(context.Context) GetServerBackupScheduleBackupPropertiesOutput +} + +type GetServerBackupScheduleBackupPropertiesArgs struct { + Name pulumi.StringInput `pulumi:"name"` + RetentionPeriod pulumi.IntInput `pulumi:"retentionPeriod"` + VolumeIds pulumi.StringArrayInput `pulumi:"volumeIds"` +} + +func (GetServerBackupScheduleBackupPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (i GetServerBackupScheduleBackupPropertiesArgs) ToGetServerBackupScheduleBackupPropertiesOutput() GetServerBackupScheduleBackupPropertiesOutput { + return i.ToGetServerBackupScheduleBackupPropertiesOutputWithContext(context.Background()) +} + +func (i GetServerBackupScheduleBackupPropertiesArgs) ToGetServerBackupScheduleBackupPropertiesOutputWithContext(ctx context.Context) GetServerBackupScheduleBackupPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerBackupScheduleBackupPropertiesOutput) +} + +type GetServerBackupScheduleBackupPropertiesOutput struct{ *pulumi.OutputState } + +func (GetServerBackupScheduleBackupPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupScheduleBackupProperties)(nil)).Elem() +} + +func (o GetServerBackupScheduleBackupPropertiesOutput) ToGetServerBackupScheduleBackupPropertiesOutput() GetServerBackupScheduleBackupPropertiesOutput { + return o +} + +func (o GetServerBackupScheduleBackupPropertiesOutput) ToGetServerBackupScheduleBackupPropertiesOutputWithContext(ctx context.Context) GetServerBackupScheduleBackupPropertiesOutput { + return o +} + +func (o GetServerBackupScheduleBackupPropertiesOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupScheduleBackupProperties) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetServerBackupScheduleBackupPropertiesOutput) RetentionPeriod() pulumi.IntOutput { + return o.ApplyT(func(v GetServerBackupScheduleBackupProperties) int { return v.RetentionPeriod }).(pulumi.IntOutput) +} + +func (o GetServerBackupScheduleBackupPropertiesOutput) VolumeIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetServerBackupScheduleBackupProperties) []string { return v.VolumeIds }).(pulumi.StringArrayOutput) +} + +type GetServerBackupSchedulesItem struct { + // Backup schedule details for the backups. + BackupProperties GetServerBackupSchedulesItemBackupProperties `pulumi:"backupProperties"` + BackupScheduleId int `pulumi:"backupScheduleId"` + // Is the backup schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + // The backup schedule name. + Name string `pulumi:"name"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` +} + +// GetServerBackupSchedulesItemInput is an input type that accepts GetServerBackupSchedulesItemArgs and GetServerBackupSchedulesItemOutput values. +// You can construct a concrete instance of `GetServerBackupSchedulesItemInput` via: +// +// GetServerBackupSchedulesItemArgs{...} +type GetServerBackupSchedulesItemInput interface { + pulumi.Input + + ToGetServerBackupSchedulesItemOutput() GetServerBackupSchedulesItemOutput + ToGetServerBackupSchedulesItemOutputWithContext(context.Context) GetServerBackupSchedulesItemOutput +} + +type GetServerBackupSchedulesItemArgs struct { + // Backup schedule details for the backups. + BackupProperties GetServerBackupSchedulesItemBackupPropertiesInput `pulumi:"backupProperties"` + BackupScheduleId pulumi.IntInput `pulumi:"backupScheduleId"` + // Is the backup schedule enabled or disabled. + Enabled pulumi.BoolInput `pulumi:"enabled"` + // The backup schedule name. + Name pulumi.StringInput `pulumi:"name"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringInput `pulumi:"rrule"` +} + +func (GetServerBackupSchedulesItemArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesItem)(nil)).Elem() +} + +func (i GetServerBackupSchedulesItemArgs) ToGetServerBackupSchedulesItemOutput() GetServerBackupSchedulesItemOutput { + return i.ToGetServerBackupSchedulesItemOutputWithContext(context.Background()) +} + +func (i GetServerBackupSchedulesItemArgs) ToGetServerBackupSchedulesItemOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerBackupSchedulesItemOutput) +} + +// GetServerBackupSchedulesItemArrayInput is an input type that accepts GetServerBackupSchedulesItemArray and GetServerBackupSchedulesItemArrayOutput values. +// You can construct a concrete instance of `GetServerBackupSchedulesItemArrayInput` via: +// +// GetServerBackupSchedulesItemArray{ GetServerBackupSchedulesItemArgs{...} } +type GetServerBackupSchedulesItemArrayInput interface { + pulumi.Input + + ToGetServerBackupSchedulesItemArrayOutput() GetServerBackupSchedulesItemArrayOutput + ToGetServerBackupSchedulesItemArrayOutputWithContext(context.Context) GetServerBackupSchedulesItemArrayOutput +} + +type GetServerBackupSchedulesItemArray []GetServerBackupSchedulesItemInput + +func (GetServerBackupSchedulesItemArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetServerBackupSchedulesItem)(nil)).Elem() +} + +func (i GetServerBackupSchedulesItemArray) ToGetServerBackupSchedulesItemArrayOutput() GetServerBackupSchedulesItemArrayOutput { + return i.ToGetServerBackupSchedulesItemArrayOutputWithContext(context.Background()) +} + +func (i GetServerBackupSchedulesItemArray) ToGetServerBackupSchedulesItemArrayOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerBackupSchedulesItemArrayOutput) +} + +type GetServerBackupSchedulesItemOutput struct{ *pulumi.OutputState } + +func (GetServerBackupSchedulesItemOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesItem)(nil)).Elem() +} + +func (o GetServerBackupSchedulesItemOutput) ToGetServerBackupSchedulesItemOutput() GetServerBackupSchedulesItemOutput { + return o +} + +func (o GetServerBackupSchedulesItemOutput) ToGetServerBackupSchedulesItemOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemOutput { + return o +} + +// Backup schedule details for the backups. +func (o GetServerBackupSchedulesItemOutput) BackupProperties() GetServerBackupSchedulesItemBackupPropertiesOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItem) GetServerBackupSchedulesItemBackupProperties { + return v.BackupProperties + }).(GetServerBackupSchedulesItemBackupPropertiesOutput) +} + +func (o GetServerBackupSchedulesItemOutput) BackupScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItem) int { return v.BackupScheduleId }).(pulumi.IntOutput) +} + +// Is the backup schedule enabled or disabled. +func (o GetServerBackupSchedulesItemOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItem) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +// The backup schedule name. +func (o GetServerBackupSchedulesItemOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItem) string { return v.Name }).(pulumi.StringOutput) +} + +// Backup schedule described in `rrule` (recurrence rule) format. +func (o GetServerBackupSchedulesItemOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItem) string { return v.Rrule }).(pulumi.StringOutput) +} + +type GetServerBackupSchedulesItemArrayOutput struct{ *pulumi.OutputState } + +func (GetServerBackupSchedulesItemArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetServerBackupSchedulesItem)(nil)).Elem() +} + +func (o GetServerBackupSchedulesItemArrayOutput) ToGetServerBackupSchedulesItemArrayOutput() GetServerBackupSchedulesItemArrayOutput { + return o +} + +func (o GetServerBackupSchedulesItemArrayOutput) ToGetServerBackupSchedulesItemArrayOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemArrayOutput { + return o +} + +func (o GetServerBackupSchedulesItemArrayOutput) Index(i pulumi.IntInput) GetServerBackupSchedulesItemOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetServerBackupSchedulesItem { + return vs[0].([]GetServerBackupSchedulesItem)[vs[1].(int)] + }).(GetServerBackupSchedulesItemOutput) +} + +type GetServerBackupSchedulesItemBackupProperties struct { + Name string `pulumi:"name"` + RetentionPeriod int `pulumi:"retentionPeriod"` + VolumeIds []string `pulumi:"volumeIds"` +} + +// GetServerBackupSchedulesItemBackupPropertiesInput is an input type that accepts GetServerBackupSchedulesItemBackupPropertiesArgs and GetServerBackupSchedulesItemBackupPropertiesOutput values. +// You can construct a concrete instance of `GetServerBackupSchedulesItemBackupPropertiesInput` via: +// +// GetServerBackupSchedulesItemBackupPropertiesArgs{...} +type GetServerBackupSchedulesItemBackupPropertiesInput interface { + pulumi.Input + + ToGetServerBackupSchedulesItemBackupPropertiesOutput() GetServerBackupSchedulesItemBackupPropertiesOutput + ToGetServerBackupSchedulesItemBackupPropertiesOutputWithContext(context.Context) GetServerBackupSchedulesItemBackupPropertiesOutput +} + +type GetServerBackupSchedulesItemBackupPropertiesArgs struct { + Name pulumi.StringInput `pulumi:"name"` + RetentionPeriod pulumi.IntInput `pulumi:"retentionPeriod"` + VolumeIds pulumi.StringArrayInput `pulumi:"volumeIds"` +} + +func (GetServerBackupSchedulesItemBackupPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesItemBackupProperties)(nil)).Elem() +} + +func (i GetServerBackupSchedulesItemBackupPropertiesArgs) ToGetServerBackupSchedulesItemBackupPropertiesOutput() GetServerBackupSchedulesItemBackupPropertiesOutput { + return i.ToGetServerBackupSchedulesItemBackupPropertiesOutputWithContext(context.Background()) +} + +func (i GetServerBackupSchedulesItemBackupPropertiesArgs) ToGetServerBackupSchedulesItemBackupPropertiesOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemBackupPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerBackupSchedulesItemBackupPropertiesOutput) +} + +type GetServerBackupSchedulesItemBackupPropertiesOutput struct{ *pulumi.OutputState } + +func (GetServerBackupSchedulesItemBackupPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBackupSchedulesItemBackupProperties)(nil)).Elem() +} + +func (o GetServerBackupSchedulesItemBackupPropertiesOutput) ToGetServerBackupSchedulesItemBackupPropertiesOutput() GetServerBackupSchedulesItemBackupPropertiesOutput { + return o +} + +func (o GetServerBackupSchedulesItemBackupPropertiesOutput) ToGetServerBackupSchedulesItemBackupPropertiesOutputWithContext(ctx context.Context) GetServerBackupSchedulesItemBackupPropertiesOutput { + return o +} + +func (o GetServerBackupSchedulesItemBackupPropertiesOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItemBackupProperties) string { return v.Name }).(pulumi.StringOutput) +} + +func (o GetServerBackupSchedulesItemBackupPropertiesOutput) RetentionPeriod() pulumi.IntOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItemBackupProperties) int { return v.RetentionPeriod }).(pulumi.IntOutput) +} + +func (o GetServerBackupSchedulesItemBackupPropertiesOutput) VolumeIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetServerBackupSchedulesItemBackupProperties) []string { return v.VolumeIds }).(pulumi.StringArrayOutput) +} + +type GetServerBootVolume struct { + // Delete the volume during the termination of the server. + DeleteOnTermination bool `pulumi:"deleteOnTermination"` + // The ID of the boot volume + Id string `pulumi:"id"` +} + +// GetServerBootVolumeInput is an input type that accepts GetServerBootVolumeArgs and GetServerBootVolumeOutput values. +// You can construct a concrete instance of `GetServerBootVolumeInput` via: +// +// GetServerBootVolumeArgs{...} +type GetServerBootVolumeInput interface { + pulumi.Input + + ToGetServerBootVolumeOutput() GetServerBootVolumeOutput + ToGetServerBootVolumeOutputWithContext(context.Context) GetServerBootVolumeOutput +} + +type GetServerBootVolumeArgs struct { + // Delete the volume during the termination of the server. + DeleteOnTermination pulumi.BoolInput `pulumi:"deleteOnTermination"` + // The ID of the boot volume + Id pulumi.StringInput `pulumi:"id"` +} + +func (GetServerBootVolumeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBootVolume)(nil)).Elem() +} + +func (i GetServerBootVolumeArgs) ToGetServerBootVolumeOutput() GetServerBootVolumeOutput { + return i.ToGetServerBootVolumeOutputWithContext(context.Background()) +} + +func (i GetServerBootVolumeArgs) ToGetServerBootVolumeOutputWithContext(ctx context.Context) GetServerBootVolumeOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerBootVolumeOutput) +} + +type GetServerBootVolumeOutput struct{ *pulumi.OutputState } + +func (GetServerBootVolumeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerBootVolume)(nil)).Elem() +} + +func (o GetServerBootVolumeOutput) ToGetServerBootVolumeOutput() GetServerBootVolumeOutput { + return o +} + +func (o GetServerBootVolumeOutput) ToGetServerBootVolumeOutputWithContext(ctx context.Context) GetServerBootVolumeOutput { + return o +} + +// Delete the volume during the termination of the server. +func (o GetServerBootVolumeOutput) DeleteOnTermination() pulumi.BoolOutput { + return o.ApplyT(func(v GetServerBootVolume) bool { return v.DeleteOnTermination }).(pulumi.BoolOutput) +} + +// The ID of the boot volume +func (o GetServerBootVolumeOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetServerBootVolume) string { return v.Id }).(pulumi.StringOutput) +} + +type GetServerUpdateSchedulesItem struct { + // Is the update schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + // Maintenance window [1..24]. + MaintenanceWindow int `pulumi:"maintenanceWindow"` + // The update schedule name. + Name string `pulumi:"name"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` + UpdateScheduleId int `pulumi:"updateScheduleId"` +} + +// GetServerUpdateSchedulesItemInput is an input type that accepts GetServerUpdateSchedulesItemArgs and GetServerUpdateSchedulesItemOutput values. +// You can construct a concrete instance of `GetServerUpdateSchedulesItemInput` via: +// +// GetServerUpdateSchedulesItemArgs{...} +type GetServerUpdateSchedulesItemInput interface { + pulumi.Input + + ToGetServerUpdateSchedulesItemOutput() GetServerUpdateSchedulesItemOutput + ToGetServerUpdateSchedulesItemOutputWithContext(context.Context) GetServerUpdateSchedulesItemOutput +} + +type GetServerUpdateSchedulesItemArgs struct { + // Is the update schedule enabled or disabled. + Enabled pulumi.BoolInput `pulumi:"enabled"` + // Maintenance window [1..24]. + MaintenanceWindow pulumi.IntInput `pulumi:"maintenanceWindow"` + // The update schedule name. + Name pulumi.StringInput `pulumi:"name"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringInput `pulumi:"rrule"` + UpdateScheduleId pulumi.IntInput `pulumi:"updateScheduleId"` +} + +func (GetServerUpdateSchedulesItemArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerUpdateSchedulesItem)(nil)).Elem() +} + +func (i GetServerUpdateSchedulesItemArgs) ToGetServerUpdateSchedulesItemOutput() GetServerUpdateSchedulesItemOutput { + return i.ToGetServerUpdateSchedulesItemOutputWithContext(context.Background()) +} + +func (i GetServerUpdateSchedulesItemArgs) ToGetServerUpdateSchedulesItemOutputWithContext(ctx context.Context) GetServerUpdateSchedulesItemOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerUpdateSchedulesItemOutput) +} + +// GetServerUpdateSchedulesItemArrayInput is an input type that accepts GetServerUpdateSchedulesItemArray and GetServerUpdateSchedulesItemArrayOutput values. +// You can construct a concrete instance of `GetServerUpdateSchedulesItemArrayInput` via: +// +// GetServerUpdateSchedulesItemArray{ GetServerUpdateSchedulesItemArgs{...} } +type GetServerUpdateSchedulesItemArrayInput interface { + pulumi.Input + + ToGetServerUpdateSchedulesItemArrayOutput() GetServerUpdateSchedulesItemArrayOutput + ToGetServerUpdateSchedulesItemArrayOutputWithContext(context.Context) GetServerUpdateSchedulesItemArrayOutput +} + +type GetServerUpdateSchedulesItemArray []GetServerUpdateSchedulesItemInput + +func (GetServerUpdateSchedulesItemArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetServerUpdateSchedulesItem)(nil)).Elem() +} + +func (i GetServerUpdateSchedulesItemArray) ToGetServerUpdateSchedulesItemArrayOutput() GetServerUpdateSchedulesItemArrayOutput { + return i.ToGetServerUpdateSchedulesItemArrayOutputWithContext(context.Background()) +} + +func (i GetServerUpdateSchedulesItemArray) ToGetServerUpdateSchedulesItemArrayOutputWithContext(ctx context.Context) GetServerUpdateSchedulesItemArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetServerUpdateSchedulesItemArrayOutput) +} + +type GetServerUpdateSchedulesItemOutput struct{ *pulumi.OutputState } + +func (GetServerUpdateSchedulesItemOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetServerUpdateSchedulesItem)(nil)).Elem() +} + +func (o GetServerUpdateSchedulesItemOutput) ToGetServerUpdateSchedulesItemOutput() GetServerUpdateSchedulesItemOutput { + return o +} + +func (o GetServerUpdateSchedulesItemOutput) ToGetServerUpdateSchedulesItemOutputWithContext(ctx context.Context) GetServerUpdateSchedulesItemOutput { + return o +} + +// Is the update schedule enabled or disabled. +func (o GetServerUpdateSchedulesItemOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesItem) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +// Maintenance window [1..24]. +func (o GetServerUpdateSchedulesItemOutput) MaintenanceWindow() pulumi.IntOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesItem) int { return v.MaintenanceWindow }).(pulumi.IntOutput) +} + +// The update schedule name. +func (o GetServerUpdateSchedulesItemOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesItem) string { return v.Name }).(pulumi.StringOutput) +} + +// Update schedule described in `rrule` (recurrence rule) format. +func (o GetServerUpdateSchedulesItemOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesItem) string { return v.Rrule }).(pulumi.StringOutput) +} + +func (o GetServerUpdateSchedulesItemOutput) UpdateScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v GetServerUpdateSchedulesItem) int { return v.UpdateScheduleId }).(pulumi.IntOutput) +} + +type GetServerUpdateSchedulesItemArrayOutput struct{ *pulumi.OutputState } + +func (GetServerUpdateSchedulesItemArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetServerUpdateSchedulesItem)(nil)).Elem() +} + +func (o GetServerUpdateSchedulesItemArrayOutput) ToGetServerUpdateSchedulesItemArrayOutput() GetServerUpdateSchedulesItemArrayOutput { + return o +} + +func (o GetServerUpdateSchedulesItemArrayOutput) ToGetServerUpdateSchedulesItemArrayOutputWithContext(ctx context.Context) GetServerUpdateSchedulesItemArrayOutput { + return o +} + +func (o GetServerUpdateSchedulesItemArrayOutput) Index(i pulumi.IntInput) GetServerUpdateSchedulesItemOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetServerUpdateSchedulesItem { + return vs[0].([]GetServerUpdateSchedulesItem)[vs[1].(int)] + }).(GetServerUpdateSchedulesItemOutput) +} + +type GetSkeClusterExtensions struct { + // Cluster access control configuration + Acl GetSkeClusterExtensionsAcl `pulumi:"acl"` + // A single argus block as defined below + Argus GetSkeClusterExtensionsArgus `pulumi:"argus"` + // DNS extension configuration + Dns GetSkeClusterExtensionsDns `pulumi:"dns"` +} + +// GetSkeClusterExtensionsInput is an input type that accepts GetSkeClusterExtensionsArgs and GetSkeClusterExtensionsOutput values. +// You can construct a concrete instance of `GetSkeClusterExtensionsInput` via: +// +// GetSkeClusterExtensionsArgs{...} +type GetSkeClusterExtensionsInput interface { + pulumi.Input + + ToGetSkeClusterExtensionsOutput() GetSkeClusterExtensionsOutput + ToGetSkeClusterExtensionsOutputWithContext(context.Context) GetSkeClusterExtensionsOutput +} + +type GetSkeClusterExtensionsArgs struct { + // Cluster access control configuration + Acl GetSkeClusterExtensionsAclInput `pulumi:"acl"` + // A single argus block as defined below + Argus GetSkeClusterExtensionsArgusInput `pulumi:"argus"` + // DNS extension configuration + Dns GetSkeClusterExtensionsDnsInput `pulumi:"dns"` +} + +func (GetSkeClusterExtensionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensions)(nil)).Elem() +} + +func (i GetSkeClusterExtensionsArgs) ToGetSkeClusterExtensionsOutput() GetSkeClusterExtensionsOutput { + return i.ToGetSkeClusterExtensionsOutputWithContext(context.Background()) +} + +func (i GetSkeClusterExtensionsArgs) ToGetSkeClusterExtensionsOutputWithContext(ctx context.Context) GetSkeClusterExtensionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterExtensionsOutput) +} + +type GetSkeClusterExtensionsOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterExtensionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensions)(nil)).Elem() +} + +func (o GetSkeClusterExtensionsOutput) ToGetSkeClusterExtensionsOutput() GetSkeClusterExtensionsOutput { + return o +} + +func (o GetSkeClusterExtensionsOutput) ToGetSkeClusterExtensionsOutputWithContext(ctx context.Context) GetSkeClusterExtensionsOutput { + return o +} + +// Cluster access control configuration +func (o GetSkeClusterExtensionsOutput) Acl() GetSkeClusterExtensionsAclOutput { + return o.ApplyT(func(v GetSkeClusterExtensions) GetSkeClusterExtensionsAcl { return v.Acl }).(GetSkeClusterExtensionsAclOutput) +} + +// A single argus block as defined below +func (o GetSkeClusterExtensionsOutput) Argus() GetSkeClusterExtensionsArgusOutput { + return o.ApplyT(func(v GetSkeClusterExtensions) GetSkeClusterExtensionsArgus { return v.Argus }).(GetSkeClusterExtensionsArgusOutput) +} + +// DNS extension configuration +func (o GetSkeClusterExtensionsOutput) Dns() GetSkeClusterExtensionsDnsOutput { + return o.ApplyT(func(v GetSkeClusterExtensions) GetSkeClusterExtensionsDns { return v.Dns }).(GetSkeClusterExtensionsDnsOutput) +} + +type GetSkeClusterExtensionsAcl struct { + // Specify a list of CIDRs to whitelist + AllowedCidrs []string `pulumi:"allowedCidrs"` + // Is ACL enabled? + Enabled bool `pulumi:"enabled"` +} + +// GetSkeClusterExtensionsAclInput is an input type that accepts GetSkeClusterExtensionsAclArgs and GetSkeClusterExtensionsAclOutput values. +// You can construct a concrete instance of `GetSkeClusterExtensionsAclInput` via: +// +// GetSkeClusterExtensionsAclArgs{...} +type GetSkeClusterExtensionsAclInput interface { + pulumi.Input + + ToGetSkeClusterExtensionsAclOutput() GetSkeClusterExtensionsAclOutput + ToGetSkeClusterExtensionsAclOutputWithContext(context.Context) GetSkeClusterExtensionsAclOutput +} + +type GetSkeClusterExtensionsAclArgs struct { + // Specify a list of CIDRs to whitelist + AllowedCidrs pulumi.StringArrayInput `pulumi:"allowedCidrs"` + // Is ACL enabled? + Enabled pulumi.BoolInput `pulumi:"enabled"` +} + +func (GetSkeClusterExtensionsAclArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsAcl)(nil)).Elem() +} + +func (i GetSkeClusterExtensionsAclArgs) ToGetSkeClusterExtensionsAclOutput() GetSkeClusterExtensionsAclOutput { + return i.ToGetSkeClusterExtensionsAclOutputWithContext(context.Background()) +} + +func (i GetSkeClusterExtensionsAclArgs) ToGetSkeClusterExtensionsAclOutputWithContext(ctx context.Context) GetSkeClusterExtensionsAclOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterExtensionsAclOutput) +} + +type GetSkeClusterExtensionsAclOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterExtensionsAclOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsAcl)(nil)).Elem() +} + +func (o GetSkeClusterExtensionsAclOutput) ToGetSkeClusterExtensionsAclOutput() GetSkeClusterExtensionsAclOutput { + return o +} + +func (o GetSkeClusterExtensionsAclOutput) ToGetSkeClusterExtensionsAclOutputWithContext(ctx context.Context) GetSkeClusterExtensionsAclOutput { + return o +} + +// Specify a list of CIDRs to whitelist +func (o GetSkeClusterExtensionsAclOutput) AllowedCidrs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsAcl) []string { return v.AllowedCidrs }).(pulumi.StringArrayOutput) +} + +// Is ACL enabled? +func (o GetSkeClusterExtensionsAclOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsAcl) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +type GetSkeClusterExtensionsArgus struct { + // Instance ID of argus + ArgusInstanceId string `pulumi:"argusInstanceId"` + // Flag to enable/disable argus extensions. + Enabled bool `pulumi:"enabled"` +} + +// GetSkeClusterExtensionsArgusInput is an input type that accepts GetSkeClusterExtensionsArgusArgs and GetSkeClusterExtensionsArgusOutput values. +// You can construct a concrete instance of `GetSkeClusterExtensionsArgusInput` via: +// +// GetSkeClusterExtensionsArgusArgs{...} +type GetSkeClusterExtensionsArgusInput interface { + pulumi.Input + + ToGetSkeClusterExtensionsArgusOutput() GetSkeClusterExtensionsArgusOutput + ToGetSkeClusterExtensionsArgusOutputWithContext(context.Context) GetSkeClusterExtensionsArgusOutput +} + +type GetSkeClusterExtensionsArgusArgs struct { + // Instance ID of argus + ArgusInstanceId pulumi.StringInput `pulumi:"argusInstanceId"` + // Flag to enable/disable argus extensions. + Enabled pulumi.BoolInput `pulumi:"enabled"` +} + +func (GetSkeClusterExtensionsArgusArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsArgus)(nil)).Elem() +} + +func (i GetSkeClusterExtensionsArgusArgs) ToGetSkeClusterExtensionsArgusOutput() GetSkeClusterExtensionsArgusOutput { + return i.ToGetSkeClusterExtensionsArgusOutputWithContext(context.Background()) +} + +func (i GetSkeClusterExtensionsArgusArgs) ToGetSkeClusterExtensionsArgusOutputWithContext(ctx context.Context) GetSkeClusterExtensionsArgusOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterExtensionsArgusOutput) +} + +type GetSkeClusterExtensionsArgusOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterExtensionsArgusOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsArgus)(nil)).Elem() +} + +func (o GetSkeClusterExtensionsArgusOutput) ToGetSkeClusterExtensionsArgusOutput() GetSkeClusterExtensionsArgusOutput { + return o +} + +func (o GetSkeClusterExtensionsArgusOutput) ToGetSkeClusterExtensionsArgusOutputWithContext(ctx context.Context) GetSkeClusterExtensionsArgusOutput { + return o +} + +// Instance ID of argus +func (o GetSkeClusterExtensionsArgusOutput) ArgusInstanceId() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsArgus) string { return v.ArgusInstanceId }).(pulumi.StringOutput) +} + +// Flag to enable/disable argus extensions. +func (o GetSkeClusterExtensionsArgusOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsArgus) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +type GetSkeClusterExtensionsDns struct { + // Flag to enable/disable DNS extensions + Enabled bool `pulumi:"enabled"` + // Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + Zones []string `pulumi:"zones"` +} + +// GetSkeClusterExtensionsDnsInput is an input type that accepts GetSkeClusterExtensionsDnsArgs and GetSkeClusterExtensionsDnsOutput values. +// You can construct a concrete instance of `GetSkeClusterExtensionsDnsInput` via: +// +// GetSkeClusterExtensionsDnsArgs{...} +type GetSkeClusterExtensionsDnsInput interface { + pulumi.Input + + ToGetSkeClusterExtensionsDnsOutput() GetSkeClusterExtensionsDnsOutput + ToGetSkeClusterExtensionsDnsOutputWithContext(context.Context) GetSkeClusterExtensionsDnsOutput +} + +type GetSkeClusterExtensionsDnsArgs struct { + // Flag to enable/disable DNS extensions + Enabled pulumi.BoolInput `pulumi:"enabled"` + // Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + Zones pulumi.StringArrayInput `pulumi:"zones"` +} + +func (GetSkeClusterExtensionsDnsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsDns)(nil)).Elem() +} + +func (i GetSkeClusterExtensionsDnsArgs) ToGetSkeClusterExtensionsDnsOutput() GetSkeClusterExtensionsDnsOutput { + return i.ToGetSkeClusterExtensionsDnsOutputWithContext(context.Background()) +} + +func (i GetSkeClusterExtensionsDnsArgs) ToGetSkeClusterExtensionsDnsOutputWithContext(ctx context.Context) GetSkeClusterExtensionsDnsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterExtensionsDnsOutput) +} + +type GetSkeClusterExtensionsDnsOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterExtensionsDnsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterExtensionsDns)(nil)).Elem() +} + +func (o GetSkeClusterExtensionsDnsOutput) ToGetSkeClusterExtensionsDnsOutput() GetSkeClusterExtensionsDnsOutput { + return o +} + +func (o GetSkeClusterExtensionsDnsOutput) ToGetSkeClusterExtensionsDnsOutputWithContext(ctx context.Context) GetSkeClusterExtensionsDnsOutput { + return o +} + +// Flag to enable/disable DNS extensions +func (o GetSkeClusterExtensionsDnsOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsDns) bool { return v.Enabled }).(pulumi.BoolOutput) +} + +// Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) +func (o GetSkeClusterExtensionsDnsOutput) Zones() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSkeClusterExtensionsDns) []string { return v.Zones }).(pulumi.StringArrayOutput) +} + +type GetSkeClusterHibernation struct { + // End time of hibernation, in crontab syntax. + End string `pulumi:"end"` + // Start time of cluster hibernation in crontab syntax. + Start string `pulumi:"start"` + // Timezone name corresponding to a file in the IANA Time Zone database. + Timezone string `pulumi:"timezone"` +} + +// GetSkeClusterHibernationInput is an input type that accepts GetSkeClusterHibernationArgs and GetSkeClusterHibernationOutput values. +// You can construct a concrete instance of `GetSkeClusterHibernationInput` via: +// +// GetSkeClusterHibernationArgs{...} +type GetSkeClusterHibernationInput interface { + pulumi.Input + + ToGetSkeClusterHibernationOutput() GetSkeClusterHibernationOutput + ToGetSkeClusterHibernationOutputWithContext(context.Context) GetSkeClusterHibernationOutput +} + +type GetSkeClusterHibernationArgs struct { + // End time of hibernation, in crontab syntax. + End pulumi.StringInput `pulumi:"end"` + // Start time of cluster hibernation in crontab syntax. + Start pulumi.StringInput `pulumi:"start"` + // Timezone name corresponding to a file in the IANA Time Zone database. + Timezone pulumi.StringInput `pulumi:"timezone"` +} + +func (GetSkeClusterHibernationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterHibernation)(nil)).Elem() +} + +func (i GetSkeClusterHibernationArgs) ToGetSkeClusterHibernationOutput() GetSkeClusterHibernationOutput { + return i.ToGetSkeClusterHibernationOutputWithContext(context.Background()) +} + +func (i GetSkeClusterHibernationArgs) ToGetSkeClusterHibernationOutputWithContext(ctx context.Context) GetSkeClusterHibernationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterHibernationOutput) +} + +// GetSkeClusterHibernationArrayInput is an input type that accepts GetSkeClusterHibernationArray and GetSkeClusterHibernationArrayOutput values. +// You can construct a concrete instance of `GetSkeClusterHibernationArrayInput` via: +// +// GetSkeClusterHibernationArray{ GetSkeClusterHibernationArgs{...} } +type GetSkeClusterHibernationArrayInput interface { + pulumi.Input + + ToGetSkeClusterHibernationArrayOutput() GetSkeClusterHibernationArrayOutput + ToGetSkeClusterHibernationArrayOutputWithContext(context.Context) GetSkeClusterHibernationArrayOutput +} + +type GetSkeClusterHibernationArray []GetSkeClusterHibernationInput + +func (GetSkeClusterHibernationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterHibernation)(nil)).Elem() +} + +func (i GetSkeClusterHibernationArray) ToGetSkeClusterHibernationArrayOutput() GetSkeClusterHibernationArrayOutput { + return i.ToGetSkeClusterHibernationArrayOutputWithContext(context.Background()) +} + +func (i GetSkeClusterHibernationArray) ToGetSkeClusterHibernationArrayOutputWithContext(ctx context.Context) GetSkeClusterHibernationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterHibernationArrayOutput) +} + +type GetSkeClusterHibernationOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterHibernationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterHibernation)(nil)).Elem() +} + +func (o GetSkeClusterHibernationOutput) ToGetSkeClusterHibernationOutput() GetSkeClusterHibernationOutput { + return o +} + +func (o GetSkeClusterHibernationOutput) ToGetSkeClusterHibernationOutputWithContext(ctx context.Context) GetSkeClusterHibernationOutput { + return o +} + +// End time of hibernation, in crontab syntax. +func (o GetSkeClusterHibernationOutput) End() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterHibernation) string { return v.End }).(pulumi.StringOutput) +} + +// Start time of cluster hibernation in crontab syntax. +func (o GetSkeClusterHibernationOutput) Start() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterHibernation) string { return v.Start }).(pulumi.StringOutput) +} + +// Timezone name corresponding to a file in the IANA Time Zone database. +func (o GetSkeClusterHibernationOutput) Timezone() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterHibernation) string { return v.Timezone }).(pulumi.StringOutput) +} + +type GetSkeClusterHibernationArrayOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterHibernationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterHibernation)(nil)).Elem() +} + +func (o GetSkeClusterHibernationArrayOutput) ToGetSkeClusterHibernationArrayOutput() GetSkeClusterHibernationArrayOutput { + return o +} + +func (o GetSkeClusterHibernationArrayOutput) ToGetSkeClusterHibernationArrayOutputWithContext(ctx context.Context) GetSkeClusterHibernationArrayOutput { + return o +} + +func (o GetSkeClusterHibernationArrayOutput) Index(i pulumi.IntInput) GetSkeClusterHibernationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetSkeClusterHibernation { + return vs[0].([]GetSkeClusterHibernation)[vs[1].(int)] + }).(GetSkeClusterHibernationOutput) +} + +type GetSkeClusterMaintenance struct { + // Flag to enable/disable auto-updates of the Kubernetes version. + EnableKubernetesVersionUpdates bool `pulumi:"enableKubernetesVersionUpdates"` + // Flag to enable/disable auto-updates of the OS image version. + EnableMachineImageVersionUpdates bool `pulumi:"enableMachineImageVersionUpdates"` + // Date time for maintenance window end. + End string `pulumi:"end"` + // Date time for maintenance window start. + Start string `pulumi:"start"` +} + +// GetSkeClusterMaintenanceInput is an input type that accepts GetSkeClusterMaintenanceArgs and GetSkeClusterMaintenanceOutput values. +// You can construct a concrete instance of `GetSkeClusterMaintenanceInput` via: +// +// GetSkeClusterMaintenanceArgs{...} +type GetSkeClusterMaintenanceInput interface { + pulumi.Input + + ToGetSkeClusterMaintenanceOutput() GetSkeClusterMaintenanceOutput + ToGetSkeClusterMaintenanceOutputWithContext(context.Context) GetSkeClusterMaintenanceOutput +} + +type GetSkeClusterMaintenanceArgs struct { + // Flag to enable/disable auto-updates of the Kubernetes version. + EnableKubernetesVersionUpdates pulumi.BoolInput `pulumi:"enableKubernetesVersionUpdates"` + // Flag to enable/disable auto-updates of the OS image version. + EnableMachineImageVersionUpdates pulumi.BoolInput `pulumi:"enableMachineImageVersionUpdates"` + // Date time for maintenance window end. + End pulumi.StringInput `pulumi:"end"` + // Date time for maintenance window start. + Start pulumi.StringInput `pulumi:"start"` +} + +func (GetSkeClusterMaintenanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterMaintenance)(nil)).Elem() +} + +func (i GetSkeClusterMaintenanceArgs) ToGetSkeClusterMaintenanceOutput() GetSkeClusterMaintenanceOutput { + return i.ToGetSkeClusterMaintenanceOutputWithContext(context.Background()) +} + +func (i GetSkeClusterMaintenanceArgs) ToGetSkeClusterMaintenanceOutputWithContext(ctx context.Context) GetSkeClusterMaintenanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterMaintenanceOutput) +} + +type GetSkeClusterMaintenanceOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterMaintenanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterMaintenance)(nil)).Elem() +} + +func (o GetSkeClusterMaintenanceOutput) ToGetSkeClusterMaintenanceOutput() GetSkeClusterMaintenanceOutput { + return o +} + +func (o GetSkeClusterMaintenanceOutput) ToGetSkeClusterMaintenanceOutputWithContext(ctx context.Context) GetSkeClusterMaintenanceOutput { + return o +} + +// Flag to enable/disable auto-updates of the Kubernetes version. +func (o GetSkeClusterMaintenanceOutput) EnableKubernetesVersionUpdates() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterMaintenance) bool { return v.EnableKubernetesVersionUpdates }).(pulumi.BoolOutput) +} + +// Flag to enable/disable auto-updates of the OS image version. +func (o GetSkeClusterMaintenanceOutput) EnableMachineImageVersionUpdates() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterMaintenance) bool { return v.EnableMachineImageVersionUpdates }).(pulumi.BoolOutput) +} + +// Date time for maintenance window end. +func (o GetSkeClusterMaintenanceOutput) End() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterMaintenance) string { return v.End }).(pulumi.StringOutput) +} + +// Date time for maintenance window start. +func (o GetSkeClusterMaintenanceOutput) Start() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterMaintenance) string { return v.Start }).(pulumi.StringOutput) +} + +type GetSkeClusterNetwork struct { + // ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + Id string `pulumi:"id"` +} + +// GetSkeClusterNetworkInput is an input type that accepts GetSkeClusterNetworkArgs and GetSkeClusterNetworkOutput values. +// You can construct a concrete instance of `GetSkeClusterNetworkInput` via: +// +// GetSkeClusterNetworkArgs{...} +type GetSkeClusterNetworkInput interface { + pulumi.Input + + ToGetSkeClusterNetworkOutput() GetSkeClusterNetworkOutput + ToGetSkeClusterNetworkOutputWithContext(context.Context) GetSkeClusterNetworkOutput +} + +type GetSkeClusterNetworkArgs struct { + // ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + Id pulumi.StringInput `pulumi:"id"` +} + +func (GetSkeClusterNetworkArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNetwork)(nil)).Elem() +} + +func (i GetSkeClusterNetworkArgs) ToGetSkeClusterNetworkOutput() GetSkeClusterNetworkOutput { + return i.ToGetSkeClusterNetworkOutputWithContext(context.Background()) +} + +func (i GetSkeClusterNetworkArgs) ToGetSkeClusterNetworkOutputWithContext(ctx context.Context) GetSkeClusterNetworkOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterNetworkOutput) +} + +type GetSkeClusterNetworkOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterNetworkOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNetwork)(nil)).Elem() +} + +func (o GetSkeClusterNetworkOutput) ToGetSkeClusterNetworkOutput() GetSkeClusterNetworkOutput { + return o +} + +func (o GetSkeClusterNetworkOutput) ToGetSkeClusterNetworkOutputWithContext(ctx context.Context) GetSkeClusterNetworkOutput { + return o +} + +// ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. +func (o GetSkeClusterNetworkOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNetwork) string { return v.Id }).(pulumi.StringOutput) +} + +type GetSkeClusterNodePool struct { + // Allow system components to run on this node pool. + AllowSystemComponents bool `pulumi:"allowSystemComponents"` + // Specify a list of availability zones. + AvailabilityZones []string `pulumi:"availabilityZones"` + // Specifies the container runtime. + Cri string `pulumi:"cri"` + // Labels to add to each node. + Labels map[string]string `pulumi:"labels"` + // The machine type. + MachineType string `pulumi:"machineType"` + // The maximum number of nodes upgraded simultaneously. + MaxSurge int `pulumi:"maxSurge"` + // The maximum number of nodes unavailable during upgraded. + MaxUnavailable int `pulumi:"maxUnavailable"` + // Maximum number of nodes in the pool. + Maximum int `pulumi:"maximum"` + // Minimum number of nodes in the pool. + Minimum int `pulumi:"minimum"` + // Specifies the name of the node pool. + Name string `pulumi:"name"` + // The name of the OS image. + OsName string `pulumi:"osName"` + // The OS image version. + OsVersion string `pulumi:"osVersion"` + // The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + OsVersionMin string `pulumi:"osVersionMin"` + // Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + OsVersionUsed string `pulumi:"osVersionUsed"` + // Specifies a taint list as defined below. + Taints []GetSkeClusterNodePoolTaint `pulumi:"taints"` + // The volume size in GB. + VolumeSize int `pulumi:"volumeSize"` + // Specifies the volume type. + VolumeType string `pulumi:"volumeType"` +} + +// GetSkeClusterNodePoolInput is an input type that accepts GetSkeClusterNodePoolArgs and GetSkeClusterNodePoolOutput values. +// You can construct a concrete instance of `GetSkeClusterNodePoolInput` via: +// +// GetSkeClusterNodePoolArgs{...} +type GetSkeClusterNodePoolInput interface { + pulumi.Input + + ToGetSkeClusterNodePoolOutput() GetSkeClusterNodePoolOutput + ToGetSkeClusterNodePoolOutputWithContext(context.Context) GetSkeClusterNodePoolOutput +} + +type GetSkeClusterNodePoolArgs struct { + // Allow system components to run on this node pool. + AllowSystemComponents pulumi.BoolInput `pulumi:"allowSystemComponents"` + // Specify a list of availability zones. + AvailabilityZones pulumi.StringArrayInput `pulumi:"availabilityZones"` + // Specifies the container runtime. + Cri pulumi.StringInput `pulumi:"cri"` + // Labels to add to each node. + Labels pulumi.StringMapInput `pulumi:"labels"` + // The machine type. + MachineType pulumi.StringInput `pulumi:"machineType"` + // The maximum number of nodes upgraded simultaneously. + MaxSurge pulumi.IntInput `pulumi:"maxSurge"` + // The maximum number of nodes unavailable during upgraded. + MaxUnavailable pulumi.IntInput `pulumi:"maxUnavailable"` + // Maximum number of nodes in the pool. + Maximum pulumi.IntInput `pulumi:"maximum"` + // Minimum number of nodes in the pool. + Minimum pulumi.IntInput `pulumi:"minimum"` + // Specifies the name of the node pool. + Name pulumi.StringInput `pulumi:"name"` + // The name of the OS image. + OsName pulumi.StringInput `pulumi:"osName"` + // The OS image version. + OsVersion pulumi.StringInput `pulumi:"osVersion"` + // The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + OsVersionMin pulumi.StringInput `pulumi:"osVersionMin"` + // Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + OsVersionUsed pulumi.StringInput `pulumi:"osVersionUsed"` + // Specifies a taint list as defined below. + Taints GetSkeClusterNodePoolTaintArrayInput `pulumi:"taints"` + // The volume size in GB. + VolumeSize pulumi.IntInput `pulumi:"volumeSize"` + // Specifies the volume type. + VolumeType pulumi.StringInput `pulumi:"volumeType"` +} + +func (GetSkeClusterNodePoolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNodePool)(nil)).Elem() +} + +func (i GetSkeClusterNodePoolArgs) ToGetSkeClusterNodePoolOutput() GetSkeClusterNodePoolOutput { + return i.ToGetSkeClusterNodePoolOutputWithContext(context.Background()) +} + +func (i GetSkeClusterNodePoolArgs) ToGetSkeClusterNodePoolOutputWithContext(ctx context.Context) GetSkeClusterNodePoolOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterNodePoolOutput) +} + +// GetSkeClusterNodePoolArrayInput is an input type that accepts GetSkeClusterNodePoolArray and GetSkeClusterNodePoolArrayOutput values. +// You can construct a concrete instance of `GetSkeClusterNodePoolArrayInput` via: +// +// GetSkeClusterNodePoolArray{ GetSkeClusterNodePoolArgs{...} } +type GetSkeClusterNodePoolArrayInput interface { + pulumi.Input + + ToGetSkeClusterNodePoolArrayOutput() GetSkeClusterNodePoolArrayOutput + ToGetSkeClusterNodePoolArrayOutputWithContext(context.Context) GetSkeClusterNodePoolArrayOutput +} + +type GetSkeClusterNodePoolArray []GetSkeClusterNodePoolInput + +func (GetSkeClusterNodePoolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterNodePool)(nil)).Elem() +} + +func (i GetSkeClusterNodePoolArray) ToGetSkeClusterNodePoolArrayOutput() GetSkeClusterNodePoolArrayOutput { + return i.ToGetSkeClusterNodePoolArrayOutputWithContext(context.Background()) +} + +func (i GetSkeClusterNodePoolArray) ToGetSkeClusterNodePoolArrayOutputWithContext(ctx context.Context) GetSkeClusterNodePoolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterNodePoolArrayOutput) +} + +type GetSkeClusterNodePoolOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterNodePoolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNodePool)(nil)).Elem() +} + +func (o GetSkeClusterNodePoolOutput) ToGetSkeClusterNodePoolOutput() GetSkeClusterNodePoolOutput { + return o +} + +func (o GetSkeClusterNodePoolOutput) ToGetSkeClusterNodePoolOutputWithContext(ctx context.Context) GetSkeClusterNodePoolOutput { + return o +} + +// Allow system components to run on this node pool. +func (o GetSkeClusterNodePoolOutput) AllowSystemComponents() pulumi.BoolOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) bool { return v.AllowSystemComponents }).(pulumi.BoolOutput) +} + +// Specify a list of availability zones. +func (o GetSkeClusterNodePoolOutput) AvailabilityZones() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) []string { return v.AvailabilityZones }).(pulumi.StringArrayOutput) +} + +// Specifies the container runtime. +func (o GetSkeClusterNodePoolOutput) Cri() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.Cri }).(pulumi.StringOutput) +} + +// Labels to add to each node. +func (o GetSkeClusterNodePoolOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) map[string]string { return v.Labels }).(pulumi.StringMapOutput) +} + +// The machine type. +func (o GetSkeClusterNodePoolOutput) MachineType() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.MachineType }).(pulumi.StringOutput) +} + +// The maximum number of nodes upgraded simultaneously. +func (o GetSkeClusterNodePoolOutput) MaxSurge() pulumi.IntOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) int { return v.MaxSurge }).(pulumi.IntOutput) +} + +// The maximum number of nodes unavailable during upgraded. +func (o GetSkeClusterNodePoolOutput) MaxUnavailable() pulumi.IntOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) int { return v.MaxUnavailable }).(pulumi.IntOutput) +} + +// Maximum number of nodes in the pool. +func (o GetSkeClusterNodePoolOutput) Maximum() pulumi.IntOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) int { return v.Maximum }).(pulumi.IntOutput) +} + +// Minimum number of nodes in the pool. +func (o GetSkeClusterNodePoolOutput) Minimum() pulumi.IntOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) int { return v.Minimum }).(pulumi.IntOutput) +} + +// Specifies the name of the node pool. +func (o GetSkeClusterNodePoolOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.Name }).(pulumi.StringOutput) +} + +// The name of the OS image. +func (o GetSkeClusterNodePoolOutput) OsName() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.OsName }).(pulumi.StringOutput) +} + +// The OS image version. +func (o GetSkeClusterNodePoolOutput) OsVersion() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.OsVersion }).(pulumi.StringOutput) +} + +// The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. +func (o GetSkeClusterNodePoolOutput) OsVersionMin() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.OsVersionMin }).(pulumi.StringOutput) +} + +// Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o GetSkeClusterNodePoolOutput) OsVersionUsed() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.OsVersionUsed }).(pulumi.StringOutput) +} + +// Specifies a taint list as defined below. +func (o GetSkeClusterNodePoolOutput) Taints() GetSkeClusterNodePoolTaintArrayOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) []GetSkeClusterNodePoolTaint { return v.Taints }).(GetSkeClusterNodePoolTaintArrayOutput) +} + +// The volume size in GB. +func (o GetSkeClusterNodePoolOutput) VolumeSize() pulumi.IntOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) int { return v.VolumeSize }).(pulumi.IntOutput) +} + +// Specifies the volume type. +func (o GetSkeClusterNodePoolOutput) VolumeType() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePool) string { return v.VolumeType }).(pulumi.StringOutput) +} + +type GetSkeClusterNodePoolArrayOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterNodePoolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterNodePool)(nil)).Elem() +} + +func (o GetSkeClusterNodePoolArrayOutput) ToGetSkeClusterNodePoolArrayOutput() GetSkeClusterNodePoolArrayOutput { + return o +} + +func (o GetSkeClusterNodePoolArrayOutput) ToGetSkeClusterNodePoolArrayOutputWithContext(ctx context.Context) GetSkeClusterNodePoolArrayOutput { + return o +} + +func (o GetSkeClusterNodePoolArrayOutput) Index(i pulumi.IntInput) GetSkeClusterNodePoolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetSkeClusterNodePool { + return vs[0].([]GetSkeClusterNodePool)[vs[1].(int)] + }).(GetSkeClusterNodePoolOutput) +} + +type GetSkeClusterNodePoolTaint struct { + // The taint effect. + Effect string `pulumi:"effect"` + // Taint key to be applied to a node. + Key string `pulumi:"key"` + // Taint value corresponding to the taint key. + Value string `pulumi:"value"` +} + +// GetSkeClusterNodePoolTaintInput is an input type that accepts GetSkeClusterNodePoolTaintArgs and GetSkeClusterNodePoolTaintOutput values. +// You can construct a concrete instance of `GetSkeClusterNodePoolTaintInput` via: +// +// GetSkeClusterNodePoolTaintArgs{...} +type GetSkeClusterNodePoolTaintInput interface { + pulumi.Input + + ToGetSkeClusterNodePoolTaintOutput() GetSkeClusterNodePoolTaintOutput + ToGetSkeClusterNodePoolTaintOutputWithContext(context.Context) GetSkeClusterNodePoolTaintOutput +} + +type GetSkeClusterNodePoolTaintArgs struct { + // The taint effect. + Effect pulumi.StringInput `pulumi:"effect"` + // Taint key to be applied to a node. + Key pulumi.StringInput `pulumi:"key"` + // Taint value corresponding to the taint key. + Value pulumi.StringInput `pulumi:"value"` +} + +func (GetSkeClusterNodePoolTaintArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNodePoolTaint)(nil)).Elem() +} + +func (i GetSkeClusterNodePoolTaintArgs) ToGetSkeClusterNodePoolTaintOutput() GetSkeClusterNodePoolTaintOutput { + return i.ToGetSkeClusterNodePoolTaintOutputWithContext(context.Background()) +} + +func (i GetSkeClusterNodePoolTaintArgs) ToGetSkeClusterNodePoolTaintOutputWithContext(ctx context.Context) GetSkeClusterNodePoolTaintOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterNodePoolTaintOutput) +} + +// GetSkeClusterNodePoolTaintArrayInput is an input type that accepts GetSkeClusterNodePoolTaintArray and GetSkeClusterNodePoolTaintArrayOutput values. +// You can construct a concrete instance of `GetSkeClusterNodePoolTaintArrayInput` via: +// +// GetSkeClusterNodePoolTaintArray{ GetSkeClusterNodePoolTaintArgs{...} } +type GetSkeClusterNodePoolTaintArrayInput interface { + pulumi.Input + + ToGetSkeClusterNodePoolTaintArrayOutput() GetSkeClusterNodePoolTaintArrayOutput + ToGetSkeClusterNodePoolTaintArrayOutputWithContext(context.Context) GetSkeClusterNodePoolTaintArrayOutput +} + +type GetSkeClusterNodePoolTaintArray []GetSkeClusterNodePoolTaintInput + +func (GetSkeClusterNodePoolTaintArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterNodePoolTaint)(nil)).Elem() +} + +func (i GetSkeClusterNodePoolTaintArray) ToGetSkeClusterNodePoolTaintArrayOutput() GetSkeClusterNodePoolTaintArrayOutput { + return i.ToGetSkeClusterNodePoolTaintArrayOutputWithContext(context.Background()) +} + +func (i GetSkeClusterNodePoolTaintArray) ToGetSkeClusterNodePoolTaintArrayOutputWithContext(ctx context.Context) GetSkeClusterNodePoolTaintArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSkeClusterNodePoolTaintArrayOutput) +} + +type GetSkeClusterNodePoolTaintOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterNodePoolTaintOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSkeClusterNodePoolTaint)(nil)).Elem() +} + +func (o GetSkeClusterNodePoolTaintOutput) ToGetSkeClusterNodePoolTaintOutput() GetSkeClusterNodePoolTaintOutput { + return o +} + +func (o GetSkeClusterNodePoolTaintOutput) ToGetSkeClusterNodePoolTaintOutputWithContext(ctx context.Context) GetSkeClusterNodePoolTaintOutput { + return o +} + +// The taint effect. +func (o GetSkeClusterNodePoolTaintOutput) Effect() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePoolTaint) string { return v.Effect }).(pulumi.StringOutput) +} + +// Taint key to be applied to a node. +func (o GetSkeClusterNodePoolTaintOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePoolTaint) string { return v.Key }).(pulumi.StringOutput) +} + +// Taint value corresponding to the taint key. +func (o GetSkeClusterNodePoolTaintOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v GetSkeClusterNodePoolTaint) string { return v.Value }).(pulumi.StringOutput) +} + +type GetSkeClusterNodePoolTaintArrayOutput struct{ *pulumi.OutputState } + +func (GetSkeClusterNodePoolTaintArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetSkeClusterNodePoolTaint)(nil)).Elem() +} + +func (o GetSkeClusterNodePoolTaintArrayOutput) ToGetSkeClusterNodePoolTaintArrayOutput() GetSkeClusterNodePoolTaintArrayOutput { + return o +} + +func (o GetSkeClusterNodePoolTaintArrayOutput) ToGetSkeClusterNodePoolTaintArrayOutputWithContext(ctx context.Context) GetSkeClusterNodePoolTaintArrayOutput { + return o +} + +func (o GetSkeClusterNodePoolTaintArrayOutput) Index(i pulumi.IntInput) GetSkeClusterNodePoolTaintOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetSkeClusterNodePoolTaint { + return vs[0].([]GetSkeClusterNodePoolTaint)[vs[1].(int)] + }).(GetSkeClusterNodePoolTaintOutput) +} + +type GetSqlserverflexInstanceFlavor struct { + Cpu int `pulumi:"cpu"` + Description string `pulumi:"description"` + Id string `pulumi:"id"` + Ram int `pulumi:"ram"` +} + +// GetSqlserverflexInstanceFlavorInput is an input type that accepts GetSqlserverflexInstanceFlavorArgs and GetSqlserverflexInstanceFlavorOutput values. +// You can construct a concrete instance of `GetSqlserverflexInstanceFlavorInput` via: +// +// GetSqlserverflexInstanceFlavorArgs{...} +type GetSqlserverflexInstanceFlavorInput interface { + pulumi.Input + + ToGetSqlserverflexInstanceFlavorOutput() GetSqlserverflexInstanceFlavorOutput + ToGetSqlserverflexInstanceFlavorOutputWithContext(context.Context) GetSqlserverflexInstanceFlavorOutput +} + +type GetSqlserverflexInstanceFlavorArgs struct { + Cpu pulumi.IntInput `pulumi:"cpu"` + Description pulumi.StringInput `pulumi:"description"` + Id pulumi.StringInput `pulumi:"id"` + Ram pulumi.IntInput `pulumi:"ram"` +} + +func (GetSqlserverflexInstanceFlavorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (i GetSqlserverflexInstanceFlavorArgs) ToGetSqlserverflexInstanceFlavorOutput() GetSqlserverflexInstanceFlavorOutput { + return i.ToGetSqlserverflexInstanceFlavorOutputWithContext(context.Background()) +} + +func (i GetSqlserverflexInstanceFlavorArgs) ToGetSqlserverflexInstanceFlavorOutputWithContext(ctx context.Context) GetSqlserverflexInstanceFlavorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSqlserverflexInstanceFlavorOutput) +} + +type GetSqlserverflexInstanceFlavorOutput struct{ *pulumi.OutputState } + +func (GetSqlserverflexInstanceFlavorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceFlavor)(nil)).Elem() +} + +func (o GetSqlserverflexInstanceFlavorOutput) ToGetSqlserverflexInstanceFlavorOutput() GetSqlserverflexInstanceFlavorOutput { + return o +} + +func (o GetSqlserverflexInstanceFlavorOutput) ToGetSqlserverflexInstanceFlavorOutputWithContext(ctx context.Context) GetSqlserverflexInstanceFlavorOutput { + return o +} + +func (o GetSqlserverflexInstanceFlavorOutput) Cpu() pulumi.IntOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceFlavor) int { return v.Cpu }).(pulumi.IntOutput) +} + +func (o GetSqlserverflexInstanceFlavorOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceFlavor) string { return v.Description }).(pulumi.StringOutput) +} + +func (o GetSqlserverflexInstanceFlavorOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceFlavor) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetSqlserverflexInstanceFlavorOutput) Ram() pulumi.IntOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceFlavor) int { return v.Ram }).(pulumi.IntOutput) +} + +type GetSqlserverflexInstanceOptions struct { + Edition string `pulumi:"edition"` + RetentionDays int `pulumi:"retentionDays"` +} + +// GetSqlserverflexInstanceOptionsInput is an input type that accepts GetSqlserverflexInstanceOptionsArgs and GetSqlserverflexInstanceOptionsOutput values. +// You can construct a concrete instance of `GetSqlserverflexInstanceOptionsInput` via: +// +// GetSqlserverflexInstanceOptionsArgs{...} +type GetSqlserverflexInstanceOptionsInput interface { + pulumi.Input + + ToGetSqlserverflexInstanceOptionsOutput() GetSqlserverflexInstanceOptionsOutput + ToGetSqlserverflexInstanceOptionsOutputWithContext(context.Context) GetSqlserverflexInstanceOptionsOutput +} + +type GetSqlserverflexInstanceOptionsArgs struct { + Edition pulumi.StringInput `pulumi:"edition"` + RetentionDays pulumi.IntInput `pulumi:"retentionDays"` +} + +func (GetSqlserverflexInstanceOptionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceOptions)(nil)).Elem() +} + +func (i GetSqlserverflexInstanceOptionsArgs) ToGetSqlserverflexInstanceOptionsOutput() GetSqlserverflexInstanceOptionsOutput { + return i.ToGetSqlserverflexInstanceOptionsOutputWithContext(context.Background()) +} + +func (i GetSqlserverflexInstanceOptionsArgs) ToGetSqlserverflexInstanceOptionsOutputWithContext(ctx context.Context) GetSqlserverflexInstanceOptionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSqlserverflexInstanceOptionsOutput) +} + +type GetSqlserverflexInstanceOptionsOutput struct{ *pulumi.OutputState } + +func (GetSqlserverflexInstanceOptionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceOptions)(nil)).Elem() +} + +func (o GetSqlserverflexInstanceOptionsOutput) ToGetSqlserverflexInstanceOptionsOutput() GetSqlserverflexInstanceOptionsOutput { + return o +} + +func (o GetSqlserverflexInstanceOptionsOutput) ToGetSqlserverflexInstanceOptionsOutputWithContext(ctx context.Context) GetSqlserverflexInstanceOptionsOutput { + return o +} + +func (o GetSqlserverflexInstanceOptionsOutput) Edition() pulumi.StringOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceOptions) string { return v.Edition }).(pulumi.StringOutput) +} + +func (o GetSqlserverflexInstanceOptionsOutput) RetentionDays() pulumi.IntOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceOptions) int { return v.RetentionDays }).(pulumi.IntOutput) +} + +type GetSqlserverflexInstanceStorage struct { + Class string `pulumi:"class"` + Size int `pulumi:"size"` +} + +// GetSqlserverflexInstanceStorageInput is an input type that accepts GetSqlserverflexInstanceStorageArgs and GetSqlserverflexInstanceStorageOutput values. +// You can construct a concrete instance of `GetSqlserverflexInstanceStorageInput` via: +// +// GetSqlserverflexInstanceStorageArgs{...} +type GetSqlserverflexInstanceStorageInput interface { + pulumi.Input + + ToGetSqlserverflexInstanceStorageOutput() GetSqlserverflexInstanceStorageOutput + ToGetSqlserverflexInstanceStorageOutputWithContext(context.Context) GetSqlserverflexInstanceStorageOutput +} + +type GetSqlserverflexInstanceStorageArgs struct { + Class pulumi.StringInput `pulumi:"class"` + Size pulumi.IntInput `pulumi:"size"` +} + +func (GetSqlserverflexInstanceStorageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceStorage)(nil)).Elem() +} + +func (i GetSqlserverflexInstanceStorageArgs) ToGetSqlserverflexInstanceStorageOutput() GetSqlserverflexInstanceStorageOutput { + return i.ToGetSqlserverflexInstanceStorageOutputWithContext(context.Background()) +} + +func (i GetSqlserverflexInstanceStorageArgs) ToGetSqlserverflexInstanceStorageOutputWithContext(ctx context.Context) GetSqlserverflexInstanceStorageOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetSqlserverflexInstanceStorageOutput) +} + +type GetSqlserverflexInstanceStorageOutput struct{ *pulumi.OutputState } + +func (GetSqlserverflexInstanceStorageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSqlserverflexInstanceStorage)(nil)).Elem() +} + +func (o GetSqlserverflexInstanceStorageOutput) ToGetSqlserverflexInstanceStorageOutput() GetSqlserverflexInstanceStorageOutput { + return o +} + +func (o GetSqlserverflexInstanceStorageOutput) ToGetSqlserverflexInstanceStorageOutputWithContext(ctx context.Context) GetSqlserverflexInstanceStorageOutput { + return o +} + +func (o GetSqlserverflexInstanceStorageOutput) Class() pulumi.StringOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceStorage) string { return v.Class }).(pulumi.StringOutput) +} + +func (o GetSqlserverflexInstanceStorageOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetSqlserverflexInstanceStorage) int { return v.Size }).(pulumi.IntOutput) +} + +type GetVolumeSource struct { + // The ID of the source, e.g. image ID + Id string `pulumi:"id"` + // The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + Type string `pulumi:"type"` +} + +// GetVolumeSourceInput is an input type that accepts GetVolumeSourceArgs and GetVolumeSourceOutput values. +// You can construct a concrete instance of `GetVolumeSourceInput` via: +// +// GetVolumeSourceArgs{...} +type GetVolumeSourceInput interface { + pulumi.Input + + ToGetVolumeSourceOutput() GetVolumeSourceOutput + ToGetVolumeSourceOutputWithContext(context.Context) GetVolumeSourceOutput +} + +type GetVolumeSourceArgs struct { + // The ID of the source, e.g. image ID + Id pulumi.StringInput `pulumi:"id"` + // The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetVolumeSourceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetVolumeSource)(nil)).Elem() +} + +func (i GetVolumeSourceArgs) ToGetVolumeSourceOutput() GetVolumeSourceOutput { + return i.ToGetVolumeSourceOutputWithContext(context.Background()) +} + +func (i GetVolumeSourceArgs) ToGetVolumeSourceOutputWithContext(ctx context.Context) GetVolumeSourceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetVolumeSourceOutput) +} + +type GetVolumeSourceOutput struct{ *pulumi.OutputState } + +func (GetVolumeSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetVolumeSource)(nil)).Elem() +} + +func (o GetVolumeSourceOutput) ToGetVolumeSourceOutput() GetVolumeSourceOutput { + return o +} + +func (o GetVolumeSourceOutput) ToGetVolumeSourceOutputWithContext(ctx context.Context) GetVolumeSourceOutput { + return o +} + +// The ID of the source, e.g. image ID +func (o GetVolumeSourceOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetVolumeSource) string { return v.Id }).(pulumi.StringOutput) +} + +// The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. +func (o GetVolumeSourceOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetVolumeSource) string { return v.Type }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionConfigInput)(nil)).Elem(), CdnDistributionConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionConfigPtrInput)(nil)).Elem(), CdnDistributionConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionConfigBackendInput)(nil)).Elem(), CdnDistributionConfigBackendArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionConfigBackendPtrInput)(nil)).Elem(), CdnDistributionConfigBackendArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionDomainInput)(nil)).Elem(), CdnDistributionDomainArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*CdnDistributionDomainArrayInput)(nil)).Elem(), CdnDistributionDomainArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageChecksumInput)(nil)).Elem(), ImageChecksumArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageChecksumPtrInput)(nil)).Elem(), ImageChecksumArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageConfigInput)(nil)).Elem(), ImageConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ImageConfigPtrInput)(nil)).Elem(), ImageConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerListenerInput)(nil)).Elem(), LoadbalancerListenerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerListenerArrayInput)(nil)).Elem(), LoadbalancerListenerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerListenerServerNameIndicatorInput)(nil)).Elem(), LoadbalancerListenerServerNameIndicatorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerListenerServerNameIndicatorArrayInput)(nil)).Elem(), LoadbalancerListenerServerNameIndicatorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerNetworkInput)(nil)).Elem(), LoadbalancerNetworkArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerNetworkArrayInput)(nil)).Elem(), LoadbalancerNetworkArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsInput)(nil)).Elem(), LoadbalancerOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsPtrInput)(nil)).Elem(), LoadbalancerOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityInput)(nil)).Elem(), LoadbalancerOptionsObservabilityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityPtrInput)(nil)).Elem(), LoadbalancerOptionsObservabilityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityLogsInput)(nil)).Elem(), LoadbalancerOptionsObservabilityLogsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityLogsPtrInput)(nil)).Elem(), LoadbalancerOptionsObservabilityLogsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityMetricsInput)(nil)).Elem(), LoadbalancerOptionsObservabilityMetricsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerOptionsObservabilityMetricsPtrInput)(nil)).Elem(), LoadbalancerOptionsObservabilityMetricsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolInput)(nil)).Elem(), LoadbalancerTargetPoolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolArrayInput)(nil)).Elem(), LoadbalancerTargetPoolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolActiveHealthCheckInput)(nil)).Elem(), LoadbalancerTargetPoolActiveHealthCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolActiveHealthCheckPtrInput)(nil)).Elem(), LoadbalancerTargetPoolActiveHealthCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolSessionPersistenceInput)(nil)).Elem(), LoadbalancerTargetPoolSessionPersistenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolSessionPersistencePtrInput)(nil)).Elem(), LoadbalancerTargetPoolSessionPersistenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolTargetInput)(nil)).Elem(), LoadbalancerTargetPoolTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LoadbalancerTargetPoolTargetArrayInput)(nil)).Elem(), LoadbalancerTargetPoolTargetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeInstanceParametersInput)(nil)).Elem(), LogmeInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*LogmeInstanceParametersPtrInput)(nil)).Elem(), LogmeInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbInstanceParametersInput)(nil)).Elem(), MariadbInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MariadbInstanceParametersPtrInput)(nil)).Elem(), MariadbInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceFlavorInput)(nil)).Elem(), MongodbflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceFlavorPtrInput)(nil)).Elem(), MongodbflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceOptionsInput)(nil)).Elem(), MongodbflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceOptionsPtrInput)(nil)).Elem(), MongodbflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceStorageInput)(nil)).Elem(), MongodbflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*MongodbflexInstanceStoragePtrInput)(nil)).Elem(), MongodbflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaNetworkRangeInput)(nil)).Elem(), NetworkAreaNetworkRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*NetworkAreaNetworkRangeArrayInput)(nil)).Elem(), NetworkAreaNetworkRangeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityAlertgroupRuleInput)(nil)).Elem(), ObservabilityAlertgroupRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityAlertgroupRuleArrayInput)(nil)).Elem(), ObservabilityAlertgroupRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigInput)(nil)).Elem(), ObservabilityInstanceAlertConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigPtrInput)(nil)).Elem(), ObservabilityInstanceAlertConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigGlobalInput)(nil)).Elem(), ObservabilityInstanceAlertConfigGlobalArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigGlobalPtrInput)(nil)).Elem(), ObservabilityInstanceAlertConfigGlobalArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverArrayInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverEmailConfigInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverEmailConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverEmailConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverWebhooksConfigInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput)(nil)).Elem(), ObservabilityInstanceAlertConfigReceiverWebhooksConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigRouteInput)(nil)).Elem(), ObservabilityInstanceAlertConfigRouteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigRoutePtrInput)(nil)).Elem(), ObservabilityInstanceAlertConfigRouteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigRouteRouteInput)(nil)).Elem(), ObservabilityInstanceAlertConfigRouteRouteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityInstanceAlertConfigRouteRouteArrayInput)(nil)).Elem(), ObservabilityInstanceAlertConfigRouteRouteArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityLogalertgroupRuleInput)(nil)).Elem(), ObservabilityLogalertgroupRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityLogalertgroupRuleArrayInput)(nil)).Elem(), ObservabilityLogalertgroupRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigBasicAuthInput)(nil)).Elem(), ObservabilityScrapeconfigBasicAuthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigBasicAuthPtrInput)(nil)).Elem(), ObservabilityScrapeconfigBasicAuthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigSaml2Input)(nil)).Elem(), ObservabilityScrapeconfigSaml2Args{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigSaml2PtrInput)(nil)).Elem(), ObservabilityScrapeconfigSaml2Args{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigTargetInput)(nil)).Elem(), ObservabilityScrapeconfigTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityScrapeconfigTargetArrayInput)(nil)).Elem(), ObservabilityScrapeconfigTargetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchInstanceParametersInput)(nil)).Elem(), OpensearchInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OpensearchInstanceParametersPtrInput)(nil)).Elem(), OpensearchInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceFlavorInput)(nil)).Elem(), PostgresflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceFlavorPtrInput)(nil)).Elem(), PostgresflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceStorageInput)(nil)).Elem(), PostgresflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*PostgresflexInstanceStoragePtrInput)(nil)).Elem(), PostgresflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqInstanceParametersInput)(nil)).Elem(), RabbitmqInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqInstanceParametersPtrInput)(nil)).Elem(), RabbitmqInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisInstanceParametersInput)(nil)).Elem(), RedisInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisInstanceParametersPtrInput)(nil)).Elem(), RedisInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleIcmpParametersInput)(nil)).Elem(), SecurityGroupRuleIcmpParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleIcmpParametersPtrInput)(nil)).Elem(), SecurityGroupRuleIcmpParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRulePortRangeInput)(nil)).Elem(), SecurityGroupRulePortRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRulePortRangePtrInput)(nil)).Elem(), SecurityGroupRulePortRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleProtocolInput)(nil)).Elem(), SecurityGroupRuleProtocolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleProtocolPtrInput)(nil)).Elem(), SecurityGroupRuleProtocolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBackupScheduleBackupPropertiesInput)(nil)).Elem(), ServerBackupScheduleBackupPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBackupScheduleBackupPropertiesPtrInput)(nil)).Elem(), ServerBackupScheduleBackupPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBootVolumeInput)(nil)).Elem(), ServerBootVolumeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBootVolumePtrInput)(nil)).Elem(), ServerBootVolumeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsInput)(nil)).Elem(), SkeClusterExtensionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsPtrInput)(nil)).Elem(), SkeClusterExtensionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsAclInput)(nil)).Elem(), SkeClusterExtensionsAclArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsAclPtrInput)(nil)).Elem(), SkeClusterExtensionsAclArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsArgusInput)(nil)).Elem(), SkeClusterExtensionsArgusArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsArgusPtrInput)(nil)).Elem(), SkeClusterExtensionsArgusArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsDnsInput)(nil)).Elem(), SkeClusterExtensionsDnsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterExtensionsDnsPtrInput)(nil)).Elem(), SkeClusterExtensionsDnsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterHibernationInput)(nil)).Elem(), SkeClusterHibernationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterHibernationArrayInput)(nil)).Elem(), SkeClusterHibernationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterMaintenanceInput)(nil)).Elem(), SkeClusterMaintenanceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterMaintenancePtrInput)(nil)).Elem(), SkeClusterMaintenanceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNetworkInput)(nil)).Elem(), SkeClusterNetworkArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNetworkPtrInput)(nil)).Elem(), SkeClusterNetworkArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNodePoolInput)(nil)).Elem(), SkeClusterNodePoolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNodePoolArrayInput)(nil)).Elem(), SkeClusterNodePoolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNodePoolTaintInput)(nil)).Elem(), SkeClusterNodePoolTaintArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterNodePoolTaintArrayInput)(nil)).Elem(), SkeClusterNodePoolTaintArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceFlavorInput)(nil)).Elem(), SqlserverflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceFlavorPtrInput)(nil)).Elem(), SqlserverflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceOptionsInput)(nil)).Elem(), SqlserverflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceOptionsPtrInput)(nil)).Elem(), SqlserverflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceStorageInput)(nil)).Elem(), SqlserverflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceStoragePtrInput)(nil)).Elem(), SqlserverflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*VolumeSourceInput)(nil)).Elem(), VolumeSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*VolumeSourcePtrInput)(nil)).Elem(), VolumeSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCdnDistributionConfigInput)(nil)).Elem(), GetCdnDistributionConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCdnDistributionConfigBackendInput)(nil)).Elem(), GetCdnDistributionConfigBackendArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCdnDistributionDomainInput)(nil)).Elem(), GetCdnDistributionDomainArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCdnDistributionDomainArrayInput)(nil)).Elem(), GetCdnDistributionDomainArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetImageChecksumInput)(nil)).Elem(), GetImageChecksumArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetImageConfigInput)(nil)).Elem(), GetImageConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerListenerInput)(nil)).Elem(), GetLoadbalancerListenerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerListenerArrayInput)(nil)).Elem(), GetLoadbalancerListenerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerListenerServerNameIndicatorInput)(nil)).Elem(), GetLoadbalancerListenerServerNameIndicatorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerListenerServerNameIndicatorArrayInput)(nil)).Elem(), GetLoadbalancerListenerServerNameIndicatorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerNetworkInput)(nil)).Elem(), GetLoadbalancerNetworkArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerNetworkArrayInput)(nil)).Elem(), GetLoadbalancerNetworkArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerOptionsInput)(nil)).Elem(), GetLoadbalancerOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerOptionsObservabilityInput)(nil)).Elem(), GetLoadbalancerOptionsObservabilityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerOptionsObservabilityLogsInput)(nil)).Elem(), GetLoadbalancerOptionsObservabilityLogsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerOptionsObservabilityMetricsInput)(nil)).Elem(), GetLoadbalancerOptionsObservabilityMetricsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolInput)(nil)).Elem(), GetLoadbalancerTargetPoolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolArrayInput)(nil)).Elem(), GetLoadbalancerTargetPoolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolActiveHealthCheckInput)(nil)).Elem(), GetLoadbalancerTargetPoolActiveHealthCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolSessionPersistenceInput)(nil)).Elem(), GetLoadbalancerTargetPoolSessionPersistenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolSessionPersistencePtrInput)(nil)).Elem(), GetLoadbalancerTargetPoolSessionPersistenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolTargetInput)(nil)).Elem(), GetLoadbalancerTargetPoolTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLoadbalancerTargetPoolTargetArrayInput)(nil)).Elem(), GetLoadbalancerTargetPoolTargetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetLogmeInstanceParametersInput)(nil)).Elem(), GetLogmeInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetMariadbInstanceParametersInput)(nil)).Elem(), GetMariadbInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetMongodbflexInstanceFlavorInput)(nil)).Elem(), GetMongodbflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetMongodbflexInstanceOptionsInput)(nil)).Elem(), GetMongodbflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetMongodbflexInstanceStorageInput)(nil)).Elem(), GetMongodbflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetNetworkAreaNetworkRangeInput)(nil)).Elem(), GetNetworkAreaNetworkRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetNetworkAreaNetworkRangeArrayInput)(nil)).Elem(), GetNetworkAreaNetworkRangeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityAlertgroupRuleInput)(nil)).Elem(), GetObservabilityAlertgroupRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityAlertgroupRuleArrayInput)(nil)).Elem(), GetObservabilityAlertgroupRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigGlobalInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigGlobalArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverArrayInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverEmailConfigInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverEmailConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverWebhooksConfigInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigRouteInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigRouteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigRouteRouteInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigRouteRouteArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityInstanceAlertConfigRouteRouteArrayInput)(nil)).Elem(), GetObservabilityInstanceAlertConfigRouteRouteArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityLogalertgroupRuleInput)(nil)).Elem(), GetObservabilityLogalertgroupRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityLogalertgroupRuleArrayInput)(nil)).Elem(), GetObservabilityLogalertgroupRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityScrapeconfigBasicAuthInput)(nil)).Elem(), GetObservabilityScrapeconfigBasicAuthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityScrapeconfigSaml2Input)(nil)).Elem(), GetObservabilityScrapeconfigSaml2Args{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityScrapeconfigTargetInput)(nil)).Elem(), GetObservabilityScrapeconfigTargetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetObservabilityScrapeconfigTargetArrayInput)(nil)).Elem(), GetObservabilityScrapeconfigTargetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOpensearchInstanceParametersInput)(nil)).Elem(), GetOpensearchInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetPostgresflexInstanceFlavorInput)(nil)).Elem(), GetPostgresflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetPostgresflexInstanceStorageInput)(nil)).Elem(), GetPostgresflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetPublicIpRangesPublicIpRangeInput)(nil)).Elem(), GetPublicIpRangesPublicIpRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetPublicIpRangesPublicIpRangeArrayInput)(nil)).Elem(), GetPublicIpRangesPublicIpRangeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRabbitmqInstanceParametersInput)(nil)).Elem(), GetRabbitmqInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRedisInstanceParametersInput)(nil)).Elem(), GetRedisInstanceParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSecurityGroupRuleIcmpParametersInput)(nil)).Elem(), GetSecurityGroupRuleIcmpParametersArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSecurityGroupRulePortRangeInput)(nil)).Elem(), GetSecurityGroupRulePortRangeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSecurityGroupRuleProtocolInput)(nil)).Elem(), GetSecurityGroupRuleProtocolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerBackupScheduleBackupPropertiesInput)(nil)).Elem(), GetServerBackupScheduleBackupPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerBackupSchedulesItemInput)(nil)).Elem(), GetServerBackupSchedulesItemArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerBackupSchedulesItemArrayInput)(nil)).Elem(), GetServerBackupSchedulesItemArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerBackupSchedulesItemBackupPropertiesInput)(nil)).Elem(), GetServerBackupSchedulesItemBackupPropertiesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerBootVolumeInput)(nil)).Elem(), GetServerBootVolumeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerUpdateSchedulesItemInput)(nil)).Elem(), GetServerUpdateSchedulesItemArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetServerUpdateSchedulesItemArrayInput)(nil)).Elem(), GetServerUpdateSchedulesItemArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterExtensionsInput)(nil)).Elem(), GetSkeClusterExtensionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterExtensionsAclInput)(nil)).Elem(), GetSkeClusterExtensionsAclArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterExtensionsArgusInput)(nil)).Elem(), GetSkeClusterExtensionsArgusArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterExtensionsDnsInput)(nil)).Elem(), GetSkeClusterExtensionsDnsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterHibernationInput)(nil)).Elem(), GetSkeClusterHibernationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterHibernationArrayInput)(nil)).Elem(), GetSkeClusterHibernationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterMaintenanceInput)(nil)).Elem(), GetSkeClusterMaintenanceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterNetworkInput)(nil)).Elem(), GetSkeClusterNetworkArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterNodePoolInput)(nil)).Elem(), GetSkeClusterNodePoolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterNodePoolArrayInput)(nil)).Elem(), GetSkeClusterNodePoolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterNodePoolTaintInput)(nil)).Elem(), GetSkeClusterNodePoolTaintArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSkeClusterNodePoolTaintArrayInput)(nil)).Elem(), GetSkeClusterNodePoolTaintArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSqlserverflexInstanceFlavorInput)(nil)).Elem(), GetSqlserverflexInstanceFlavorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSqlserverflexInstanceOptionsInput)(nil)).Elem(), GetSqlserverflexInstanceOptionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetSqlserverflexInstanceStorageInput)(nil)).Elem(), GetSqlserverflexInstanceStorageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetVolumeSourceInput)(nil)).Elem(), GetVolumeSourceArgs{}) + pulumi.RegisterOutputType(CdnDistributionConfigOutput{}) + pulumi.RegisterOutputType(CdnDistributionConfigPtrOutput{}) + pulumi.RegisterOutputType(CdnDistributionConfigBackendOutput{}) + pulumi.RegisterOutputType(CdnDistributionConfigBackendPtrOutput{}) + pulumi.RegisterOutputType(CdnDistributionDomainOutput{}) + pulumi.RegisterOutputType(CdnDistributionDomainArrayOutput{}) + pulumi.RegisterOutputType(ImageChecksumOutput{}) + pulumi.RegisterOutputType(ImageChecksumPtrOutput{}) + pulumi.RegisterOutputType(ImageConfigOutput{}) + pulumi.RegisterOutputType(ImageConfigPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerListenerOutput{}) + pulumi.RegisterOutputType(LoadbalancerListenerArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerListenerServerNameIndicatorOutput{}) + pulumi.RegisterOutputType(LoadbalancerListenerServerNameIndicatorArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerNetworkOutput{}) + pulumi.RegisterOutputType(LoadbalancerNetworkArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityLogsOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityLogsPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityMetricsOutput{}) + pulumi.RegisterOutputType(LoadbalancerOptionsObservabilityMetricsPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolArrayOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolActiveHealthCheckOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolActiveHealthCheckPtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolSessionPersistenceOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolSessionPersistencePtrOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolTargetOutput{}) + pulumi.RegisterOutputType(LoadbalancerTargetPoolTargetArrayOutput{}) + pulumi.RegisterOutputType(LogmeInstanceParametersOutput{}) + pulumi.RegisterOutputType(LogmeInstanceParametersPtrOutput{}) + pulumi.RegisterOutputType(MariadbInstanceParametersOutput{}) + pulumi.RegisterOutputType(MariadbInstanceParametersPtrOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceFlavorPtrOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceOptionsOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceOptionsPtrOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(MongodbflexInstanceStoragePtrOutput{}) + pulumi.RegisterOutputType(NetworkAreaNetworkRangeOutput{}) + pulumi.RegisterOutputType(NetworkAreaNetworkRangeArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityAlertgroupRuleOutput{}) + pulumi.RegisterOutputType(ObservabilityAlertgroupRuleArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigPtrOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigGlobalOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigGlobalPtrOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverEmailConfigOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigRouteOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigRoutePtrOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigRouteRouteOutput{}) + pulumi.RegisterOutputType(ObservabilityInstanceAlertConfigRouteRouteArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityLogalertgroupRuleOutput{}) + pulumi.RegisterOutputType(ObservabilityLogalertgroupRuleArrayOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigBasicAuthOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigBasicAuthPtrOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigSaml2Output{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigSaml2PtrOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigTargetOutput{}) + pulumi.RegisterOutputType(ObservabilityScrapeconfigTargetArrayOutput{}) + pulumi.RegisterOutputType(OpensearchInstanceParametersOutput{}) + pulumi.RegisterOutputType(OpensearchInstanceParametersPtrOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceFlavorPtrOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(PostgresflexInstanceStoragePtrOutput{}) + pulumi.RegisterOutputType(RabbitmqInstanceParametersOutput{}) + pulumi.RegisterOutputType(RabbitmqInstanceParametersPtrOutput{}) + pulumi.RegisterOutputType(RedisInstanceParametersOutput{}) + pulumi.RegisterOutputType(RedisInstanceParametersPtrOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleIcmpParametersOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleIcmpParametersPtrOutput{}) + pulumi.RegisterOutputType(SecurityGroupRulePortRangeOutput{}) + pulumi.RegisterOutputType(SecurityGroupRulePortRangePtrOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleProtocolOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleProtocolPtrOutput{}) + pulumi.RegisterOutputType(ServerBackupScheduleBackupPropertiesOutput{}) + pulumi.RegisterOutputType(ServerBackupScheduleBackupPropertiesPtrOutput{}) + pulumi.RegisterOutputType(ServerBootVolumeOutput{}) + pulumi.RegisterOutputType(ServerBootVolumePtrOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsPtrOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsAclOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsAclPtrOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsArgusOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsArgusPtrOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsDnsOutput{}) + pulumi.RegisterOutputType(SkeClusterExtensionsDnsPtrOutput{}) + pulumi.RegisterOutputType(SkeClusterHibernationOutput{}) + pulumi.RegisterOutputType(SkeClusterHibernationArrayOutput{}) + pulumi.RegisterOutputType(SkeClusterMaintenanceOutput{}) + pulumi.RegisterOutputType(SkeClusterMaintenancePtrOutput{}) + pulumi.RegisterOutputType(SkeClusterNetworkOutput{}) + pulumi.RegisterOutputType(SkeClusterNetworkPtrOutput{}) + pulumi.RegisterOutputType(SkeClusterNodePoolOutput{}) + pulumi.RegisterOutputType(SkeClusterNodePoolArrayOutput{}) + pulumi.RegisterOutputType(SkeClusterNodePoolTaintOutput{}) + pulumi.RegisterOutputType(SkeClusterNodePoolTaintArrayOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceFlavorPtrOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceOptionsOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceOptionsPtrOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceStoragePtrOutput{}) + pulumi.RegisterOutputType(VolumeSourceOutput{}) + pulumi.RegisterOutputType(VolumeSourcePtrOutput{}) + pulumi.RegisterOutputType(GetCdnDistributionConfigOutput{}) + pulumi.RegisterOutputType(GetCdnDistributionConfigBackendOutput{}) + pulumi.RegisterOutputType(GetCdnDistributionDomainOutput{}) + pulumi.RegisterOutputType(GetCdnDistributionDomainArrayOutput{}) + pulumi.RegisterOutputType(GetImageChecksumOutput{}) + pulumi.RegisterOutputType(GetImageConfigOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerListenerOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerListenerArrayOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerListenerServerNameIndicatorOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerListenerServerNameIndicatorArrayOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerNetworkOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerNetworkArrayOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerOptionsOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerOptionsObservabilityOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerOptionsObservabilityLogsOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerOptionsObservabilityMetricsOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolArrayOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolActiveHealthCheckOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolSessionPersistenceOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolSessionPersistencePtrOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolTargetOutput{}) + pulumi.RegisterOutputType(GetLoadbalancerTargetPoolTargetArrayOutput{}) + pulumi.RegisterOutputType(GetLogmeInstanceParametersOutput{}) + pulumi.RegisterOutputType(GetMariadbInstanceParametersOutput{}) + pulumi.RegisterOutputType(GetMongodbflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(GetMongodbflexInstanceOptionsOutput{}) + pulumi.RegisterOutputType(GetMongodbflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(GetNetworkAreaNetworkRangeOutput{}) + pulumi.RegisterOutputType(GetNetworkAreaNetworkRangeArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityAlertgroupRuleOutput{}) + pulumi.RegisterOutputType(GetObservabilityAlertgroupRuleArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigGlobalOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverEmailConfigOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverEmailConfigArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigRouteOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigRouteRouteOutput{}) + pulumi.RegisterOutputType(GetObservabilityInstanceAlertConfigRouteRouteArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityLogalertgroupRuleOutput{}) + pulumi.RegisterOutputType(GetObservabilityLogalertgroupRuleArrayOutput{}) + pulumi.RegisterOutputType(GetObservabilityScrapeconfigBasicAuthOutput{}) + pulumi.RegisterOutputType(GetObservabilityScrapeconfigSaml2Output{}) + pulumi.RegisterOutputType(GetObservabilityScrapeconfigTargetOutput{}) + pulumi.RegisterOutputType(GetObservabilityScrapeconfigTargetArrayOutput{}) + pulumi.RegisterOutputType(GetOpensearchInstanceParametersOutput{}) + pulumi.RegisterOutputType(GetPostgresflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(GetPostgresflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(GetPublicIpRangesPublicIpRangeOutput{}) + pulumi.RegisterOutputType(GetPublicIpRangesPublicIpRangeArrayOutput{}) + pulumi.RegisterOutputType(GetRabbitmqInstanceParametersOutput{}) + pulumi.RegisterOutputType(GetRedisInstanceParametersOutput{}) + pulumi.RegisterOutputType(GetSecurityGroupRuleIcmpParametersOutput{}) + pulumi.RegisterOutputType(GetSecurityGroupRulePortRangeOutput{}) + pulumi.RegisterOutputType(GetSecurityGroupRuleProtocolOutput{}) + pulumi.RegisterOutputType(GetServerBackupScheduleBackupPropertiesOutput{}) + pulumi.RegisterOutputType(GetServerBackupSchedulesItemOutput{}) + pulumi.RegisterOutputType(GetServerBackupSchedulesItemArrayOutput{}) + pulumi.RegisterOutputType(GetServerBackupSchedulesItemBackupPropertiesOutput{}) + pulumi.RegisterOutputType(GetServerBootVolumeOutput{}) + pulumi.RegisterOutputType(GetServerUpdateSchedulesItemOutput{}) + pulumi.RegisterOutputType(GetServerUpdateSchedulesItemArrayOutput{}) + pulumi.RegisterOutputType(GetSkeClusterExtensionsOutput{}) + pulumi.RegisterOutputType(GetSkeClusterExtensionsAclOutput{}) + pulumi.RegisterOutputType(GetSkeClusterExtensionsArgusOutput{}) + pulumi.RegisterOutputType(GetSkeClusterExtensionsDnsOutput{}) + pulumi.RegisterOutputType(GetSkeClusterHibernationOutput{}) + pulumi.RegisterOutputType(GetSkeClusterHibernationArrayOutput{}) + pulumi.RegisterOutputType(GetSkeClusterMaintenanceOutput{}) + pulumi.RegisterOutputType(GetSkeClusterNetworkOutput{}) + pulumi.RegisterOutputType(GetSkeClusterNodePoolOutput{}) + pulumi.RegisterOutputType(GetSkeClusterNodePoolArrayOutput{}) + pulumi.RegisterOutputType(GetSkeClusterNodePoolTaintOutput{}) + pulumi.RegisterOutputType(GetSkeClusterNodePoolTaintArrayOutput{}) + pulumi.RegisterOutputType(GetSqlserverflexInstanceFlavorOutput{}) + pulumi.RegisterOutputType(GetSqlserverflexInstanceOptionsOutput{}) + pulumi.RegisterOutputType(GetSqlserverflexInstanceStorageOutput{}) + pulumi.RegisterOutputType(GetVolumeSourceOutput{}) +} diff --git a/sdk/go/stackit/rabbitmqCredential.go b/sdk/go/stackit/rabbitmqCredential.go new file mode 100644 index 0000000..216a138 --- /dev/null +++ b/sdk/go/stackit/rabbitmqCredential.go @@ -0,0 +1,325 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type RabbitmqCredential struct { + pulumi.CustomResourceState + + // The credential's ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + Host pulumi.StringOutput `pulumi:"host"` + Hosts pulumi.StringArrayOutput `pulumi:"hosts"` + HttpApiUri pulumi.StringOutput `pulumi:"httpApiUri"` + HttpApiUris pulumi.StringArrayOutput `pulumi:"httpApiUris"` + // ID of the RabbitMQ instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + Management pulumi.StringOutput `pulumi:"management"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Uri pulumi.StringOutput `pulumi:"uri"` + Uris pulumi.StringArrayOutput `pulumi:"uris"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewRabbitmqCredential registers a new resource with the given unique name, arguments, and options. +func NewRabbitmqCredential(ctx *pulumi.Context, + name string, args *RabbitmqCredentialArgs, opts ...pulumi.ResourceOption) (*RabbitmqCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource RabbitmqCredential + err := ctx.RegisterResource("stackit:index/rabbitmqCredential:RabbitmqCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRabbitmqCredential gets an existing RabbitmqCredential 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 GetRabbitmqCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RabbitmqCredentialState, opts ...pulumi.ResourceOption) (*RabbitmqCredential, error) { + var resource RabbitmqCredential + err := ctx.ReadResource("stackit:index/rabbitmqCredential:RabbitmqCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RabbitmqCredential resources. +type rabbitmqCredentialState struct { + // The credential's ID. + CredentialId *string `pulumi:"credentialId"` + Host *string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + HttpApiUri *string `pulumi:"httpApiUri"` + HttpApiUris []string `pulumi:"httpApiUris"` + // ID of the RabbitMQ instance. + InstanceId *string `pulumi:"instanceId"` + Management *string `pulumi:"management"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Uri *string `pulumi:"uri"` + Uris []string `pulumi:"uris"` + Username *string `pulumi:"username"` +} + +type RabbitmqCredentialState struct { + // The credential's ID. + CredentialId pulumi.StringPtrInput + Host pulumi.StringPtrInput + Hosts pulumi.StringArrayInput + HttpApiUri pulumi.StringPtrInput + HttpApiUris pulumi.StringArrayInput + // ID of the RabbitMQ instance. + InstanceId pulumi.StringPtrInput + Management pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Uri pulumi.StringPtrInput + Uris pulumi.StringArrayInput + Username pulumi.StringPtrInput +} + +func (RabbitmqCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*rabbitmqCredentialState)(nil)).Elem() +} + +type rabbitmqCredentialArgs struct { + // ID of the RabbitMQ instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a RabbitmqCredential resource. +type RabbitmqCredentialArgs struct { + // ID of the RabbitMQ instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (RabbitmqCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*rabbitmqCredentialArgs)(nil)).Elem() +} + +type RabbitmqCredentialInput interface { + pulumi.Input + + ToRabbitmqCredentialOutput() RabbitmqCredentialOutput + ToRabbitmqCredentialOutputWithContext(ctx context.Context) RabbitmqCredentialOutput +} + +func (*RabbitmqCredential) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqCredential)(nil)).Elem() +} + +func (i *RabbitmqCredential) ToRabbitmqCredentialOutput() RabbitmqCredentialOutput { + return i.ToRabbitmqCredentialOutputWithContext(context.Background()) +} + +func (i *RabbitmqCredential) ToRabbitmqCredentialOutputWithContext(ctx context.Context) RabbitmqCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqCredentialOutput) +} + +// RabbitmqCredentialArrayInput is an input type that accepts RabbitmqCredentialArray and RabbitmqCredentialArrayOutput values. +// You can construct a concrete instance of `RabbitmqCredentialArrayInput` via: +// +// RabbitmqCredentialArray{ RabbitmqCredentialArgs{...} } +type RabbitmqCredentialArrayInput interface { + pulumi.Input + + ToRabbitmqCredentialArrayOutput() RabbitmqCredentialArrayOutput + ToRabbitmqCredentialArrayOutputWithContext(context.Context) RabbitmqCredentialArrayOutput +} + +type RabbitmqCredentialArray []RabbitmqCredentialInput + +func (RabbitmqCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RabbitmqCredential)(nil)).Elem() +} + +func (i RabbitmqCredentialArray) ToRabbitmqCredentialArrayOutput() RabbitmqCredentialArrayOutput { + return i.ToRabbitmqCredentialArrayOutputWithContext(context.Background()) +} + +func (i RabbitmqCredentialArray) ToRabbitmqCredentialArrayOutputWithContext(ctx context.Context) RabbitmqCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqCredentialArrayOutput) +} + +// RabbitmqCredentialMapInput is an input type that accepts RabbitmqCredentialMap and RabbitmqCredentialMapOutput values. +// You can construct a concrete instance of `RabbitmqCredentialMapInput` via: +// +// RabbitmqCredentialMap{ "key": RabbitmqCredentialArgs{...} } +type RabbitmqCredentialMapInput interface { + pulumi.Input + + ToRabbitmqCredentialMapOutput() RabbitmqCredentialMapOutput + ToRabbitmqCredentialMapOutputWithContext(context.Context) RabbitmqCredentialMapOutput +} + +type RabbitmqCredentialMap map[string]RabbitmqCredentialInput + +func (RabbitmqCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RabbitmqCredential)(nil)).Elem() +} + +func (i RabbitmqCredentialMap) ToRabbitmqCredentialMapOutput() RabbitmqCredentialMapOutput { + return i.ToRabbitmqCredentialMapOutputWithContext(context.Background()) +} + +func (i RabbitmqCredentialMap) ToRabbitmqCredentialMapOutputWithContext(ctx context.Context) RabbitmqCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqCredentialMapOutput) +} + +type RabbitmqCredentialOutput struct{ *pulumi.OutputState } + +func (RabbitmqCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqCredential)(nil)).Elem() +} + +func (o RabbitmqCredentialOutput) ToRabbitmqCredentialOutput() RabbitmqCredentialOutput { + return o +} + +func (o RabbitmqCredentialOutput) ToRabbitmqCredentialOutputWithContext(ctx context.Context) RabbitmqCredentialOutput { + return o +} + +// The credential's ID. +func (o RabbitmqCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringArrayOutput { return v.Hosts }).(pulumi.StringArrayOutput) +} + +func (o RabbitmqCredentialOutput) HttpApiUri() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.HttpApiUri }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) HttpApiUris() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringArrayOutput { return v.HttpApiUris }).(pulumi.StringArrayOutput) +} + +// ID of the RabbitMQ instance. +func (o RabbitmqCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Management() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.Management }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o RabbitmqCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +func (o RabbitmqCredentialOutput) Uris() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringArrayOutput { return v.Uris }).(pulumi.StringArrayOutput) +} + +func (o RabbitmqCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type RabbitmqCredentialArrayOutput struct{ *pulumi.OutputState } + +func (RabbitmqCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RabbitmqCredential)(nil)).Elem() +} + +func (o RabbitmqCredentialArrayOutput) ToRabbitmqCredentialArrayOutput() RabbitmqCredentialArrayOutput { + return o +} + +func (o RabbitmqCredentialArrayOutput) ToRabbitmqCredentialArrayOutputWithContext(ctx context.Context) RabbitmqCredentialArrayOutput { + return o +} + +func (o RabbitmqCredentialArrayOutput) Index(i pulumi.IntInput) RabbitmqCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RabbitmqCredential { + return vs[0].([]*RabbitmqCredential)[vs[1].(int)] + }).(RabbitmqCredentialOutput) +} + +type RabbitmqCredentialMapOutput struct{ *pulumi.OutputState } + +func (RabbitmqCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RabbitmqCredential)(nil)).Elem() +} + +func (o RabbitmqCredentialMapOutput) ToRabbitmqCredentialMapOutput() RabbitmqCredentialMapOutput { + return o +} + +func (o RabbitmqCredentialMapOutput) ToRabbitmqCredentialMapOutputWithContext(ctx context.Context) RabbitmqCredentialMapOutput { + return o +} + +func (o RabbitmqCredentialMapOutput) MapIndex(k pulumi.StringInput) RabbitmqCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RabbitmqCredential { + return vs[0].(map[string]*RabbitmqCredential)[vs[1].(string)] + }).(RabbitmqCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqCredentialInput)(nil)).Elem(), &RabbitmqCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqCredentialArrayInput)(nil)).Elem(), RabbitmqCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqCredentialMapInput)(nil)).Elem(), RabbitmqCredentialMap{}) + pulumi.RegisterOutputType(RabbitmqCredentialOutput{}) + pulumi.RegisterOutputType(RabbitmqCredentialArrayOutput{}) + pulumi.RegisterOutputType(RabbitmqCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/rabbitmqInstance.go b/sdk/go/stackit/rabbitmqInstance.go new file mode 100644 index 0000000..bdce907 --- /dev/null +++ b/sdk/go/stackit/rabbitmqInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type RabbitmqInstance struct { + pulumi.CustomResourceState + + CfGuid pulumi.StringOutput `pulumi:"cfGuid"` + CfOrganizationGuid pulumi.StringOutput `pulumi:"cfOrganizationGuid"` + CfSpaceGuid pulumi.StringOutput `pulumi:"cfSpaceGuid"` + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + ImageUrl pulumi.StringOutput `pulumi:"imageUrl"` + // ID of the RabbitMQ instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Parameters RabbitmqInstanceParametersOutput `pulumi:"parameters"` + // The selected plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // The selected plan name. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The service version. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewRabbitmqInstance registers a new resource with the given unique name, arguments, and options. +func NewRabbitmqInstance(ctx *pulumi.Context, + name string, args *RabbitmqInstanceArgs, opts ...pulumi.ResourceOption) (*RabbitmqInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RabbitmqInstance + err := ctx.RegisterResource("stackit:index/rabbitmqInstance:RabbitmqInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRabbitmqInstance gets an existing RabbitmqInstance 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 GetRabbitmqInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RabbitmqInstanceState, opts ...pulumi.ResourceOption) (*RabbitmqInstance, error) { + var resource RabbitmqInstance + err := ctx.ReadResource("stackit:index/rabbitmqInstance:RabbitmqInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RabbitmqInstance resources. +type rabbitmqInstanceState struct { + CfGuid *string `pulumi:"cfGuid"` + CfOrganizationGuid *string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid *string `pulumi:"cfSpaceGuid"` + DashboardUrl *string `pulumi:"dashboardUrl"` + ImageUrl *string `pulumi:"imageUrl"` + // ID of the RabbitMQ instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Parameters *RabbitmqInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId *string `pulumi:"planId"` + // The selected plan name. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The service version. + Version *string `pulumi:"version"` +} + +type RabbitmqInstanceState struct { + CfGuid pulumi.StringPtrInput + CfOrganizationGuid pulumi.StringPtrInput + CfSpaceGuid pulumi.StringPtrInput + DashboardUrl pulumi.StringPtrInput + ImageUrl pulumi.StringPtrInput + // ID of the RabbitMQ instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Parameters RabbitmqInstanceParametersPtrInput + // The selected plan ID. + PlanId pulumi.StringPtrInput + // The selected plan name. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The service version. + Version pulumi.StringPtrInput +} + +func (RabbitmqInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*rabbitmqInstanceState)(nil)).Elem() +} + +type rabbitmqInstanceArgs struct { + // Instance name. + Name *string `pulumi:"name"` + Parameters *RabbitmqInstanceParameters `pulumi:"parameters"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a RabbitmqInstance resource. +type RabbitmqInstanceArgs struct { + // Instance name. + Name pulumi.StringPtrInput + Parameters RabbitmqInstanceParametersPtrInput + // The selected plan name. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The service version. + Version pulumi.StringInput +} + +func (RabbitmqInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*rabbitmqInstanceArgs)(nil)).Elem() +} + +type RabbitmqInstanceInput interface { + pulumi.Input + + ToRabbitmqInstanceOutput() RabbitmqInstanceOutput + ToRabbitmqInstanceOutputWithContext(ctx context.Context) RabbitmqInstanceOutput +} + +func (*RabbitmqInstance) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqInstance)(nil)).Elem() +} + +func (i *RabbitmqInstance) ToRabbitmqInstanceOutput() RabbitmqInstanceOutput { + return i.ToRabbitmqInstanceOutputWithContext(context.Background()) +} + +func (i *RabbitmqInstance) ToRabbitmqInstanceOutputWithContext(ctx context.Context) RabbitmqInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceOutput) +} + +// RabbitmqInstanceArrayInput is an input type that accepts RabbitmqInstanceArray and RabbitmqInstanceArrayOutput values. +// You can construct a concrete instance of `RabbitmqInstanceArrayInput` via: +// +// RabbitmqInstanceArray{ RabbitmqInstanceArgs{...} } +type RabbitmqInstanceArrayInput interface { + pulumi.Input + + ToRabbitmqInstanceArrayOutput() RabbitmqInstanceArrayOutput + ToRabbitmqInstanceArrayOutputWithContext(context.Context) RabbitmqInstanceArrayOutput +} + +type RabbitmqInstanceArray []RabbitmqInstanceInput + +func (RabbitmqInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RabbitmqInstance)(nil)).Elem() +} + +func (i RabbitmqInstanceArray) ToRabbitmqInstanceArrayOutput() RabbitmqInstanceArrayOutput { + return i.ToRabbitmqInstanceArrayOutputWithContext(context.Background()) +} + +func (i RabbitmqInstanceArray) ToRabbitmqInstanceArrayOutputWithContext(ctx context.Context) RabbitmqInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceArrayOutput) +} + +// RabbitmqInstanceMapInput is an input type that accepts RabbitmqInstanceMap and RabbitmqInstanceMapOutput values. +// You can construct a concrete instance of `RabbitmqInstanceMapInput` via: +// +// RabbitmqInstanceMap{ "key": RabbitmqInstanceArgs{...} } +type RabbitmqInstanceMapInput interface { + pulumi.Input + + ToRabbitmqInstanceMapOutput() RabbitmqInstanceMapOutput + ToRabbitmqInstanceMapOutputWithContext(context.Context) RabbitmqInstanceMapOutput +} + +type RabbitmqInstanceMap map[string]RabbitmqInstanceInput + +func (RabbitmqInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RabbitmqInstance)(nil)).Elem() +} + +func (i RabbitmqInstanceMap) ToRabbitmqInstanceMapOutput() RabbitmqInstanceMapOutput { + return i.ToRabbitmqInstanceMapOutputWithContext(context.Background()) +} + +func (i RabbitmqInstanceMap) ToRabbitmqInstanceMapOutputWithContext(ctx context.Context) RabbitmqInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RabbitmqInstanceMapOutput) +} + +type RabbitmqInstanceOutput struct{ *pulumi.OutputState } + +func (RabbitmqInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RabbitmqInstance)(nil)).Elem() +} + +func (o RabbitmqInstanceOutput) ToRabbitmqInstanceOutput() RabbitmqInstanceOutput { + return o +} + +func (o RabbitmqInstanceOutput) ToRabbitmqInstanceOutputWithContext(ctx context.Context) RabbitmqInstanceOutput { + return o +} + +func (o RabbitmqInstanceOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o RabbitmqInstanceOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o RabbitmqInstanceOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o RabbitmqInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o RabbitmqInstanceOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the RabbitMQ instance. +func (o RabbitmqInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o RabbitmqInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o RabbitmqInstanceOutput) Parameters() RabbitmqInstanceParametersOutput { + return o.ApplyT(func(v *RabbitmqInstance) RabbitmqInstanceParametersOutput { return v.Parameters }).(RabbitmqInstanceParametersOutput) +} + +// The selected plan ID. +func (o RabbitmqInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o RabbitmqInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o RabbitmqInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o RabbitmqInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *RabbitmqInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type RabbitmqInstanceArrayOutput struct{ *pulumi.OutputState } + +func (RabbitmqInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RabbitmqInstance)(nil)).Elem() +} + +func (o RabbitmqInstanceArrayOutput) ToRabbitmqInstanceArrayOutput() RabbitmqInstanceArrayOutput { + return o +} + +func (o RabbitmqInstanceArrayOutput) ToRabbitmqInstanceArrayOutputWithContext(ctx context.Context) RabbitmqInstanceArrayOutput { + return o +} + +func (o RabbitmqInstanceArrayOutput) Index(i pulumi.IntInput) RabbitmqInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RabbitmqInstance { + return vs[0].([]*RabbitmqInstance)[vs[1].(int)] + }).(RabbitmqInstanceOutput) +} + +type RabbitmqInstanceMapOutput struct{ *pulumi.OutputState } + +func (RabbitmqInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RabbitmqInstance)(nil)).Elem() +} + +func (o RabbitmqInstanceMapOutput) ToRabbitmqInstanceMapOutput() RabbitmqInstanceMapOutput { + return o +} + +func (o RabbitmqInstanceMapOutput) ToRabbitmqInstanceMapOutputWithContext(ctx context.Context) RabbitmqInstanceMapOutput { + return o +} + +func (o RabbitmqInstanceMapOutput) MapIndex(k pulumi.StringInput) RabbitmqInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RabbitmqInstance { + return vs[0].(map[string]*RabbitmqInstance)[vs[1].(string)] + }).(RabbitmqInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqInstanceInput)(nil)).Elem(), &RabbitmqInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqInstanceArrayInput)(nil)).Elem(), RabbitmqInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RabbitmqInstanceMapInput)(nil)).Elem(), RabbitmqInstanceMap{}) + pulumi.RegisterOutputType(RabbitmqInstanceOutput{}) + pulumi.RegisterOutputType(RabbitmqInstanceArrayOutput{}) + pulumi.RegisterOutputType(RabbitmqInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/redisCredential.go b/sdk/go/stackit/redisCredential.go new file mode 100644 index 0000000..3881891 --- /dev/null +++ b/sdk/go/stackit/redisCredential.go @@ -0,0 +1,308 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Redis credential resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type RedisCredential struct { + pulumi.CustomResourceState + + // The credential's ID. + CredentialId pulumi.StringOutput `pulumi:"credentialId"` + Host pulumi.StringOutput `pulumi:"host"` + Hosts pulumi.StringArrayOutput `pulumi:"hosts"` + // ID of the Redis instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + LoadBalancedHost pulumi.StringOutput `pulumi:"loadBalancedHost"` + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Connection URI. + Uri pulumi.StringOutput `pulumi:"uri"` + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewRedisCredential registers a new resource with the given unique name, arguments, and options. +func NewRedisCredential(ctx *pulumi.Context, + name string, args *RedisCredentialArgs, opts ...pulumi.ResourceOption) (*RedisCredential, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + "uri", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource RedisCredential + err := ctx.RegisterResource("stackit:index/redisCredential:RedisCredential", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRedisCredential gets an existing RedisCredential 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 GetRedisCredential(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RedisCredentialState, opts ...pulumi.ResourceOption) (*RedisCredential, error) { + var resource RedisCredential + err := ctx.ReadResource("stackit:index/redisCredential:RedisCredential", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RedisCredential resources. +type redisCredentialState struct { + // The credential's ID. + CredentialId *string `pulumi:"credentialId"` + Host *string `pulumi:"host"` + Hosts []string `pulumi:"hosts"` + // ID of the Redis instance. + InstanceId *string `pulumi:"instanceId"` + LoadBalancedHost *string `pulumi:"loadBalancedHost"` + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // Connection URI. + Uri *string `pulumi:"uri"` + Username *string `pulumi:"username"` +} + +type RedisCredentialState struct { + // The credential's ID. + CredentialId pulumi.StringPtrInput + Host pulumi.StringPtrInput + Hosts pulumi.StringArrayInput + // ID of the Redis instance. + InstanceId pulumi.StringPtrInput + LoadBalancedHost pulumi.StringPtrInput + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // Connection URI. + Uri pulumi.StringPtrInput + Username pulumi.StringPtrInput +} + +func (RedisCredentialState) ElementType() reflect.Type { + return reflect.TypeOf((*redisCredentialState)(nil)).Elem() +} + +type redisCredentialArgs struct { + // ID of the Redis instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a RedisCredential resource. +type RedisCredentialArgs struct { + // ID of the Redis instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (RedisCredentialArgs) ElementType() reflect.Type { + return reflect.TypeOf((*redisCredentialArgs)(nil)).Elem() +} + +type RedisCredentialInput interface { + pulumi.Input + + ToRedisCredentialOutput() RedisCredentialOutput + ToRedisCredentialOutputWithContext(ctx context.Context) RedisCredentialOutput +} + +func (*RedisCredential) ElementType() reflect.Type { + return reflect.TypeOf((**RedisCredential)(nil)).Elem() +} + +func (i *RedisCredential) ToRedisCredentialOutput() RedisCredentialOutput { + return i.ToRedisCredentialOutputWithContext(context.Background()) +} + +func (i *RedisCredential) ToRedisCredentialOutputWithContext(ctx context.Context) RedisCredentialOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisCredentialOutput) +} + +// RedisCredentialArrayInput is an input type that accepts RedisCredentialArray and RedisCredentialArrayOutput values. +// You can construct a concrete instance of `RedisCredentialArrayInput` via: +// +// RedisCredentialArray{ RedisCredentialArgs{...} } +type RedisCredentialArrayInput interface { + pulumi.Input + + ToRedisCredentialArrayOutput() RedisCredentialArrayOutput + ToRedisCredentialArrayOutputWithContext(context.Context) RedisCredentialArrayOutput +} + +type RedisCredentialArray []RedisCredentialInput + +func (RedisCredentialArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RedisCredential)(nil)).Elem() +} + +func (i RedisCredentialArray) ToRedisCredentialArrayOutput() RedisCredentialArrayOutput { + return i.ToRedisCredentialArrayOutputWithContext(context.Background()) +} + +func (i RedisCredentialArray) ToRedisCredentialArrayOutputWithContext(ctx context.Context) RedisCredentialArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisCredentialArrayOutput) +} + +// RedisCredentialMapInput is an input type that accepts RedisCredentialMap and RedisCredentialMapOutput values. +// You can construct a concrete instance of `RedisCredentialMapInput` via: +// +// RedisCredentialMap{ "key": RedisCredentialArgs{...} } +type RedisCredentialMapInput interface { + pulumi.Input + + ToRedisCredentialMapOutput() RedisCredentialMapOutput + ToRedisCredentialMapOutputWithContext(context.Context) RedisCredentialMapOutput +} + +type RedisCredentialMap map[string]RedisCredentialInput + +func (RedisCredentialMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RedisCredential)(nil)).Elem() +} + +func (i RedisCredentialMap) ToRedisCredentialMapOutput() RedisCredentialMapOutput { + return i.ToRedisCredentialMapOutputWithContext(context.Background()) +} + +func (i RedisCredentialMap) ToRedisCredentialMapOutputWithContext(ctx context.Context) RedisCredentialMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisCredentialMapOutput) +} + +type RedisCredentialOutput struct{ *pulumi.OutputState } + +func (RedisCredentialOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RedisCredential)(nil)).Elem() +} + +func (o RedisCredentialOutput) ToRedisCredentialOutput() RedisCredentialOutput { + return o +} + +func (o RedisCredentialOutput) ToRedisCredentialOutputWithContext(ctx context.Context) RedisCredentialOutput { + return o +} + +// The credential's ID. +func (o RedisCredentialOutput) CredentialId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.CredentialId }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) Hosts() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringArrayOutput { return v.Hosts }).(pulumi.StringArrayOutput) +} + +// ID of the Redis instance. +func (o RedisCredentialOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) LoadBalancedHost() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.LoadBalancedHost }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o RedisCredentialOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Connection URI. +func (o RedisCredentialOutput) Uri() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.Uri }).(pulumi.StringOutput) +} + +func (o RedisCredentialOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *RedisCredential) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type RedisCredentialArrayOutput struct{ *pulumi.OutputState } + +func (RedisCredentialArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RedisCredential)(nil)).Elem() +} + +func (o RedisCredentialArrayOutput) ToRedisCredentialArrayOutput() RedisCredentialArrayOutput { + return o +} + +func (o RedisCredentialArrayOutput) ToRedisCredentialArrayOutputWithContext(ctx context.Context) RedisCredentialArrayOutput { + return o +} + +func (o RedisCredentialArrayOutput) Index(i pulumi.IntInput) RedisCredentialOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RedisCredential { + return vs[0].([]*RedisCredential)[vs[1].(int)] + }).(RedisCredentialOutput) +} + +type RedisCredentialMapOutput struct{ *pulumi.OutputState } + +func (RedisCredentialMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RedisCredential)(nil)).Elem() +} + +func (o RedisCredentialMapOutput) ToRedisCredentialMapOutput() RedisCredentialMapOutput { + return o +} + +func (o RedisCredentialMapOutput) ToRedisCredentialMapOutputWithContext(ctx context.Context) RedisCredentialMapOutput { + return o +} + +func (o RedisCredentialMapOutput) MapIndex(k pulumi.StringInput) RedisCredentialOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RedisCredential { + return vs[0].(map[string]*RedisCredential)[vs[1].(string)] + }).(RedisCredentialOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RedisCredentialInput)(nil)).Elem(), &RedisCredential{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisCredentialArrayInput)(nil)).Elem(), RedisCredentialArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisCredentialMapInput)(nil)).Elem(), RedisCredentialMap{}) + pulumi.RegisterOutputType(RedisCredentialOutput{}) + pulumi.RegisterOutputType(RedisCredentialArrayOutput{}) + pulumi.RegisterOutputType(RedisCredentialMapOutput{}) +} diff --git a/sdk/go/stackit/redisInstance.go b/sdk/go/stackit/redisInstance.go new file mode 100644 index 0000000..902288f --- /dev/null +++ b/sdk/go/stackit/redisInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Redis instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type RedisInstance struct { + pulumi.CustomResourceState + + CfGuid pulumi.StringOutput `pulumi:"cfGuid"` + CfOrganizationGuid pulumi.StringOutput `pulumi:"cfOrganizationGuid"` + CfSpaceGuid pulumi.StringOutput `pulumi:"cfSpaceGuid"` + DashboardUrl pulumi.StringOutput `pulumi:"dashboardUrl"` + ImageUrl pulumi.StringOutput `pulumi:"imageUrl"` + // ID of the Redis instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Parameters RedisInstanceParametersOutput `pulumi:"parameters"` + // The selected plan ID. + PlanId pulumi.StringOutput `pulumi:"planId"` + // The selected plan name. + PlanName pulumi.StringOutput `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The service version. + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewRedisInstance registers a new resource with the given unique name, arguments, and options. +func NewRedisInstance(ctx *pulumi.Context, + name string, args *RedisInstanceArgs, opts ...pulumi.ResourceOption) (*RedisInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PlanName == nil { + return nil, errors.New("invalid value for required argument 'PlanName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Version == nil { + return nil, errors.New("invalid value for required argument 'Version'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RedisInstance + err := ctx.RegisterResource("stackit:index/redisInstance:RedisInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRedisInstance gets an existing RedisInstance 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 GetRedisInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RedisInstanceState, opts ...pulumi.ResourceOption) (*RedisInstance, error) { + var resource RedisInstance + err := ctx.ReadResource("stackit:index/redisInstance:RedisInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RedisInstance resources. +type redisInstanceState struct { + CfGuid *string `pulumi:"cfGuid"` + CfOrganizationGuid *string `pulumi:"cfOrganizationGuid"` + CfSpaceGuid *string `pulumi:"cfSpaceGuid"` + DashboardUrl *string `pulumi:"dashboardUrl"` + ImageUrl *string `pulumi:"imageUrl"` + // ID of the Redis instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Parameters *RedisInstanceParameters `pulumi:"parameters"` + // The selected plan ID. + PlanId *string `pulumi:"planId"` + // The selected plan name. + PlanName *string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The service version. + Version *string `pulumi:"version"` +} + +type RedisInstanceState struct { + CfGuid pulumi.StringPtrInput + CfOrganizationGuid pulumi.StringPtrInput + CfSpaceGuid pulumi.StringPtrInput + DashboardUrl pulumi.StringPtrInput + ImageUrl pulumi.StringPtrInput + // ID of the Redis instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Parameters RedisInstanceParametersPtrInput + // The selected plan ID. + PlanId pulumi.StringPtrInput + // The selected plan name. + PlanName pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The service version. + Version pulumi.StringPtrInput +} + +func (RedisInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*redisInstanceState)(nil)).Elem() +} + +type redisInstanceArgs struct { + // Instance name. + Name *string `pulumi:"name"` + Parameters *RedisInstanceParameters `pulumi:"parameters"` + // The selected plan name. + PlanName string `pulumi:"planName"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The service version. + Version string `pulumi:"version"` +} + +// The set of arguments for constructing a RedisInstance resource. +type RedisInstanceArgs struct { + // Instance name. + Name pulumi.StringPtrInput + Parameters RedisInstanceParametersPtrInput + // The selected plan name. + PlanName pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The service version. + Version pulumi.StringInput +} + +func (RedisInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*redisInstanceArgs)(nil)).Elem() +} + +type RedisInstanceInput interface { + pulumi.Input + + ToRedisInstanceOutput() RedisInstanceOutput + ToRedisInstanceOutputWithContext(ctx context.Context) RedisInstanceOutput +} + +func (*RedisInstance) ElementType() reflect.Type { + return reflect.TypeOf((**RedisInstance)(nil)).Elem() +} + +func (i *RedisInstance) ToRedisInstanceOutput() RedisInstanceOutput { + return i.ToRedisInstanceOutputWithContext(context.Background()) +} + +func (i *RedisInstance) ToRedisInstanceOutputWithContext(ctx context.Context) RedisInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceOutput) +} + +// RedisInstanceArrayInput is an input type that accepts RedisInstanceArray and RedisInstanceArrayOutput values. +// You can construct a concrete instance of `RedisInstanceArrayInput` via: +// +// RedisInstanceArray{ RedisInstanceArgs{...} } +type RedisInstanceArrayInput interface { + pulumi.Input + + ToRedisInstanceArrayOutput() RedisInstanceArrayOutput + ToRedisInstanceArrayOutputWithContext(context.Context) RedisInstanceArrayOutput +} + +type RedisInstanceArray []RedisInstanceInput + +func (RedisInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RedisInstance)(nil)).Elem() +} + +func (i RedisInstanceArray) ToRedisInstanceArrayOutput() RedisInstanceArrayOutput { + return i.ToRedisInstanceArrayOutputWithContext(context.Background()) +} + +func (i RedisInstanceArray) ToRedisInstanceArrayOutputWithContext(ctx context.Context) RedisInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceArrayOutput) +} + +// RedisInstanceMapInput is an input type that accepts RedisInstanceMap and RedisInstanceMapOutput values. +// You can construct a concrete instance of `RedisInstanceMapInput` via: +// +// RedisInstanceMap{ "key": RedisInstanceArgs{...} } +type RedisInstanceMapInput interface { + pulumi.Input + + ToRedisInstanceMapOutput() RedisInstanceMapOutput + ToRedisInstanceMapOutputWithContext(context.Context) RedisInstanceMapOutput +} + +type RedisInstanceMap map[string]RedisInstanceInput + +func (RedisInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RedisInstance)(nil)).Elem() +} + +func (i RedisInstanceMap) ToRedisInstanceMapOutput() RedisInstanceMapOutput { + return i.ToRedisInstanceMapOutputWithContext(context.Background()) +} + +func (i RedisInstanceMap) ToRedisInstanceMapOutputWithContext(ctx context.Context) RedisInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RedisInstanceMapOutput) +} + +type RedisInstanceOutput struct{ *pulumi.OutputState } + +func (RedisInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RedisInstance)(nil)).Elem() +} + +func (o RedisInstanceOutput) ToRedisInstanceOutput() RedisInstanceOutput { + return o +} + +func (o RedisInstanceOutput) ToRedisInstanceOutputWithContext(ctx context.Context) RedisInstanceOutput { + return o +} + +func (o RedisInstanceOutput) CfGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.CfGuid }).(pulumi.StringOutput) +} + +func (o RedisInstanceOutput) CfOrganizationGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.CfOrganizationGuid }).(pulumi.StringOutput) +} + +func (o RedisInstanceOutput) CfSpaceGuid() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.CfSpaceGuid }).(pulumi.StringOutput) +} + +func (o RedisInstanceOutput) DashboardUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.DashboardUrl }).(pulumi.StringOutput) +} + +func (o RedisInstanceOutput) ImageUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.ImageUrl }).(pulumi.StringOutput) +} + +// ID of the Redis instance. +func (o RedisInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o RedisInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o RedisInstanceOutput) Parameters() RedisInstanceParametersOutput { + return o.ApplyT(func(v *RedisInstance) RedisInstanceParametersOutput { return v.Parameters }).(RedisInstanceParametersOutput) +} + +// The selected plan ID. +func (o RedisInstanceOutput) PlanId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.PlanId }).(pulumi.StringOutput) +} + +// The selected plan name. +func (o RedisInstanceOutput) PlanName() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.PlanName }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o RedisInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The service version. +func (o RedisInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *RedisInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type RedisInstanceArrayOutput struct{ *pulumi.OutputState } + +func (RedisInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RedisInstance)(nil)).Elem() +} + +func (o RedisInstanceArrayOutput) ToRedisInstanceArrayOutput() RedisInstanceArrayOutput { + return o +} + +func (o RedisInstanceArrayOutput) ToRedisInstanceArrayOutputWithContext(ctx context.Context) RedisInstanceArrayOutput { + return o +} + +func (o RedisInstanceArrayOutput) Index(i pulumi.IntInput) RedisInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RedisInstance { + return vs[0].([]*RedisInstance)[vs[1].(int)] + }).(RedisInstanceOutput) +} + +type RedisInstanceMapOutput struct{ *pulumi.OutputState } + +func (RedisInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RedisInstance)(nil)).Elem() +} + +func (o RedisInstanceMapOutput) ToRedisInstanceMapOutput() RedisInstanceMapOutput { + return o +} + +func (o RedisInstanceMapOutput) ToRedisInstanceMapOutputWithContext(ctx context.Context) RedisInstanceMapOutput { + return o +} + +func (o RedisInstanceMapOutput) MapIndex(k pulumi.StringInput) RedisInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RedisInstance { + return vs[0].(map[string]*RedisInstance)[vs[1].(string)] + }).(RedisInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RedisInstanceInput)(nil)).Elem(), &RedisInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisInstanceArrayInput)(nil)).Elem(), RedisInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RedisInstanceMapInput)(nil)).Elem(), RedisInstanceMap{}) + pulumi.RegisterOutputType(RedisInstanceOutput{}) + pulumi.RegisterOutputType(RedisInstanceArrayOutput{}) + pulumi.RegisterOutputType(RedisInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/resourcemanagerProject.go b/sdk/go/stackit/resourcemanagerProject.go new file mode 100644 index 0000000..cb8dca8 --- /dev/null +++ b/sdk/go/stackit/resourcemanagerProject.go @@ -0,0 +1,289 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// ## Example Usage +type ResourcemanagerProject struct { + pulumi.CustomResourceState + + // Project container ID. Globally unique, user-friendly identifier. + ContainerId pulumi.StringOutput `pulumi:"containerId"` + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + Labels pulumi.StringMapOutput `pulumi:"labels"` + // Project name. + Name pulumi.StringOutput `pulumi:"name"` + // Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + OwnerEmail pulumi.StringOutput `pulumi:"ownerEmail"` + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId pulumi.StringOutput `pulumi:"parentContainerId"` + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId pulumi.StringOutput `pulumi:"projectId"` +} + +// NewResourcemanagerProject registers a new resource with the given unique name, arguments, and options. +func NewResourcemanagerProject(ctx *pulumi.Context, + name string, args *ResourcemanagerProjectArgs, opts ...pulumi.ResourceOption) (*ResourcemanagerProject, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.OwnerEmail == nil { + return nil, errors.New("invalid value for required argument 'OwnerEmail'") + } + if args.ParentContainerId == nil { + return nil, errors.New("invalid value for required argument 'ParentContainerId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ResourcemanagerProject + err := ctx.RegisterResource("stackit:index/resourcemanagerProject:ResourcemanagerProject", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetResourcemanagerProject gets an existing ResourcemanagerProject 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 GetResourcemanagerProject(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ResourcemanagerProjectState, opts ...pulumi.ResourceOption) (*ResourcemanagerProject, error) { + var resource ResourcemanagerProject + err := ctx.ReadResource("stackit:index/resourcemanagerProject:ResourcemanagerProject", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ResourcemanagerProject resources. +type resourcemanagerProjectState struct { + // Project container ID. Globally unique, user-friendly identifier. + ContainerId *string `pulumi:"containerId"` + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + Labels map[string]string `pulumi:"labels"` + // Project name. + Name *string `pulumi:"name"` + // Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + OwnerEmail *string `pulumi:"ownerEmail"` + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId *string `pulumi:"parentContainerId"` + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId *string `pulumi:"projectId"` +} + +type ResourcemanagerProjectState struct { + // Project container ID. Globally unique, user-friendly identifier. + ContainerId pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + Labels pulumi.StringMapInput + // Project name. + Name pulumi.StringPtrInput + // Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + OwnerEmail pulumi.StringPtrInput + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId pulumi.StringPtrInput + // Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + ProjectId pulumi.StringPtrInput +} + +func (ResourcemanagerProjectState) ElementType() reflect.Type { + return reflect.TypeOf((*resourcemanagerProjectState)(nil)).Elem() +} + +type resourcemanagerProjectArgs struct { + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + Labels map[string]string `pulumi:"labels"` + // Project name. + Name *string `pulumi:"name"` + // Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + OwnerEmail string `pulumi:"ownerEmail"` + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId string `pulumi:"parentContainerId"` +} + +// The set of arguments for constructing a ResourcemanagerProject resource. +type ResourcemanagerProjectArgs struct { + // Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + Labels pulumi.StringMapInput + // Project name. + Name pulumi.StringPtrInput + // Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + OwnerEmail pulumi.StringInput + // Parent resource identifier. Both container ID (user-friendly) and UUID are supported + ParentContainerId pulumi.StringInput +} + +func (ResourcemanagerProjectArgs) ElementType() reflect.Type { + return reflect.TypeOf((*resourcemanagerProjectArgs)(nil)).Elem() +} + +type ResourcemanagerProjectInput interface { + pulumi.Input + + ToResourcemanagerProjectOutput() ResourcemanagerProjectOutput + ToResourcemanagerProjectOutputWithContext(ctx context.Context) ResourcemanagerProjectOutput +} + +func (*ResourcemanagerProject) ElementType() reflect.Type { + return reflect.TypeOf((**ResourcemanagerProject)(nil)).Elem() +} + +func (i *ResourcemanagerProject) ToResourcemanagerProjectOutput() ResourcemanagerProjectOutput { + return i.ToResourcemanagerProjectOutputWithContext(context.Background()) +} + +func (i *ResourcemanagerProject) ToResourcemanagerProjectOutputWithContext(ctx context.Context) ResourcemanagerProjectOutput { + return pulumi.ToOutputWithContext(ctx, i).(ResourcemanagerProjectOutput) +} + +// ResourcemanagerProjectArrayInput is an input type that accepts ResourcemanagerProjectArray and ResourcemanagerProjectArrayOutput values. +// You can construct a concrete instance of `ResourcemanagerProjectArrayInput` via: +// +// ResourcemanagerProjectArray{ ResourcemanagerProjectArgs{...} } +type ResourcemanagerProjectArrayInput interface { + pulumi.Input + + ToResourcemanagerProjectArrayOutput() ResourcemanagerProjectArrayOutput + ToResourcemanagerProjectArrayOutputWithContext(context.Context) ResourcemanagerProjectArrayOutput +} + +type ResourcemanagerProjectArray []ResourcemanagerProjectInput + +func (ResourcemanagerProjectArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ResourcemanagerProject)(nil)).Elem() +} + +func (i ResourcemanagerProjectArray) ToResourcemanagerProjectArrayOutput() ResourcemanagerProjectArrayOutput { + return i.ToResourcemanagerProjectArrayOutputWithContext(context.Background()) +} + +func (i ResourcemanagerProjectArray) ToResourcemanagerProjectArrayOutputWithContext(ctx context.Context) ResourcemanagerProjectArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ResourcemanagerProjectArrayOutput) +} + +// ResourcemanagerProjectMapInput is an input type that accepts ResourcemanagerProjectMap and ResourcemanagerProjectMapOutput values. +// You can construct a concrete instance of `ResourcemanagerProjectMapInput` via: +// +// ResourcemanagerProjectMap{ "key": ResourcemanagerProjectArgs{...} } +type ResourcemanagerProjectMapInput interface { + pulumi.Input + + ToResourcemanagerProjectMapOutput() ResourcemanagerProjectMapOutput + ToResourcemanagerProjectMapOutputWithContext(context.Context) ResourcemanagerProjectMapOutput +} + +type ResourcemanagerProjectMap map[string]ResourcemanagerProjectInput + +func (ResourcemanagerProjectMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ResourcemanagerProject)(nil)).Elem() +} + +func (i ResourcemanagerProjectMap) ToResourcemanagerProjectMapOutput() ResourcemanagerProjectMapOutput { + return i.ToResourcemanagerProjectMapOutputWithContext(context.Background()) +} + +func (i ResourcemanagerProjectMap) ToResourcemanagerProjectMapOutputWithContext(ctx context.Context) ResourcemanagerProjectMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ResourcemanagerProjectMapOutput) +} + +type ResourcemanagerProjectOutput struct{ *pulumi.OutputState } + +func (ResourcemanagerProjectOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ResourcemanagerProject)(nil)).Elem() +} + +func (o ResourcemanagerProjectOutput) ToResourcemanagerProjectOutput() ResourcemanagerProjectOutput { + return o +} + +func (o ResourcemanagerProjectOutput) ToResourcemanagerProjectOutputWithContext(ctx context.Context) ResourcemanagerProjectOutput { + return o +} + +// Project container ID. Globally unique, user-friendly identifier. +func (o ResourcemanagerProjectOutput) ContainerId() pulumi.StringOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringOutput { return v.ContainerId }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. +func (o ResourcemanagerProjectOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// Project name. +func (o ResourcemanagerProjectOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. +func (o ResourcemanagerProjectOutput) OwnerEmail() pulumi.StringOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringOutput { return v.OwnerEmail }).(pulumi.StringOutput) +} + +// Parent resource identifier. Both container ID (user-friendly) and UUID are supported +func (o ResourcemanagerProjectOutput) ParentContainerId() pulumi.StringOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringOutput { return v.ParentContainerId }).(pulumi.StringOutput) +} + +// Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. +func (o ResourcemanagerProjectOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ResourcemanagerProject) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +type ResourcemanagerProjectArrayOutput struct{ *pulumi.OutputState } + +func (ResourcemanagerProjectArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ResourcemanagerProject)(nil)).Elem() +} + +func (o ResourcemanagerProjectArrayOutput) ToResourcemanagerProjectArrayOutput() ResourcemanagerProjectArrayOutput { + return o +} + +func (o ResourcemanagerProjectArrayOutput) ToResourcemanagerProjectArrayOutputWithContext(ctx context.Context) ResourcemanagerProjectArrayOutput { + return o +} + +func (o ResourcemanagerProjectArrayOutput) Index(i pulumi.IntInput) ResourcemanagerProjectOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ResourcemanagerProject { + return vs[0].([]*ResourcemanagerProject)[vs[1].(int)] + }).(ResourcemanagerProjectOutput) +} + +type ResourcemanagerProjectMapOutput struct{ *pulumi.OutputState } + +func (ResourcemanagerProjectMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ResourcemanagerProject)(nil)).Elem() +} + +func (o ResourcemanagerProjectMapOutput) ToResourcemanagerProjectMapOutput() ResourcemanagerProjectMapOutput { + return o +} + +func (o ResourcemanagerProjectMapOutput) ToResourcemanagerProjectMapOutputWithContext(ctx context.Context) ResourcemanagerProjectMapOutput { + return o +} + +func (o ResourcemanagerProjectMapOutput) MapIndex(k pulumi.StringInput) ResourcemanagerProjectOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ResourcemanagerProject { + return vs[0].(map[string]*ResourcemanagerProject)[vs[1].(string)] + }).(ResourcemanagerProjectOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ResourcemanagerProjectInput)(nil)).Elem(), &ResourcemanagerProject{}) + pulumi.RegisterInputType(reflect.TypeOf((*ResourcemanagerProjectArrayInput)(nil)).Elem(), ResourcemanagerProjectArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ResourcemanagerProjectMapInput)(nil)).Elem(), ResourcemanagerProjectMap{}) + pulumi.RegisterOutputType(ResourcemanagerProjectOutput{}) + pulumi.RegisterOutputType(ResourcemanagerProjectArrayOutput{}) + pulumi.RegisterOutputType(ResourcemanagerProjectMapOutput{}) +} diff --git a/sdk/go/stackit/secretsmanagerInstance.go b/sdk/go/stackit/secretsmanagerInstance.go new file mode 100644 index 0000000..70f450f --- /dev/null +++ b/sdk/go/stackit/secretsmanagerInstance.go @@ -0,0 +1,262 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SecretsmanagerInstance struct { + pulumi.CustomResourceState + + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls pulumi.StringArrayOutput `pulumi:"acls"` + // ID of the Secrets Manager instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` +} + +// NewSecretsmanagerInstance registers a new resource with the given unique name, arguments, and options. +func NewSecretsmanagerInstance(ctx *pulumi.Context, + name string, args *SecretsmanagerInstanceArgs, opts ...pulumi.ResourceOption) (*SecretsmanagerInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource SecretsmanagerInstance + err := ctx.RegisterResource("stackit:index/secretsmanagerInstance:SecretsmanagerInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSecretsmanagerInstance gets an existing SecretsmanagerInstance 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 GetSecretsmanagerInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SecretsmanagerInstanceState, opts ...pulumi.ResourceOption) (*SecretsmanagerInstance, error) { + var resource SecretsmanagerInstance + err := ctx.ReadResource("stackit:index/secretsmanagerInstance:SecretsmanagerInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SecretsmanagerInstance resources. +type secretsmanagerInstanceState struct { + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls []string `pulumi:"acls"` + // ID of the Secrets Manager instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` +} + +type SecretsmanagerInstanceState struct { + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls pulumi.StringArrayInput + // ID of the Secrets Manager instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput +} + +func (SecretsmanagerInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*secretsmanagerInstanceState)(nil)).Elem() +} + +type secretsmanagerInstanceArgs struct { + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls []string `pulumi:"acls"` + // Instance name. + Name *string `pulumi:"name"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a SecretsmanagerInstance resource. +type SecretsmanagerInstanceArgs struct { + // The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + Acls pulumi.StringArrayInput + // Instance name. + Name pulumi.StringPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput +} + +func (SecretsmanagerInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*secretsmanagerInstanceArgs)(nil)).Elem() +} + +type SecretsmanagerInstanceInput interface { + pulumi.Input + + ToSecretsmanagerInstanceOutput() SecretsmanagerInstanceOutput + ToSecretsmanagerInstanceOutputWithContext(ctx context.Context) SecretsmanagerInstanceOutput +} + +func (*SecretsmanagerInstance) ElementType() reflect.Type { + return reflect.TypeOf((**SecretsmanagerInstance)(nil)).Elem() +} + +func (i *SecretsmanagerInstance) ToSecretsmanagerInstanceOutput() SecretsmanagerInstanceOutput { + return i.ToSecretsmanagerInstanceOutputWithContext(context.Background()) +} + +func (i *SecretsmanagerInstance) ToSecretsmanagerInstanceOutputWithContext(ctx context.Context) SecretsmanagerInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerInstanceOutput) +} + +// SecretsmanagerInstanceArrayInput is an input type that accepts SecretsmanagerInstanceArray and SecretsmanagerInstanceArrayOutput values. +// You can construct a concrete instance of `SecretsmanagerInstanceArrayInput` via: +// +// SecretsmanagerInstanceArray{ SecretsmanagerInstanceArgs{...} } +type SecretsmanagerInstanceArrayInput interface { + pulumi.Input + + ToSecretsmanagerInstanceArrayOutput() SecretsmanagerInstanceArrayOutput + ToSecretsmanagerInstanceArrayOutputWithContext(context.Context) SecretsmanagerInstanceArrayOutput +} + +type SecretsmanagerInstanceArray []SecretsmanagerInstanceInput + +func (SecretsmanagerInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecretsmanagerInstance)(nil)).Elem() +} + +func (i SecretsmanagerInstanceArray) ToSecretsmanagerInstanceArrayOutput() SecretsmanagerInstanceArrayOutput { + return i.ToSecretsmanagerInstanceArrayOutputWithContext(context.Background()) +} + +func (i SecretsmanagerInstanceArray) ToSecretsmanagerInstanceArrayOutputWithContext(ctx context.Context) SecretsmanagerInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerInstanceArrayOutput) +} + +// SecretsmanagerInstanceMapInput is an input type that accepts SecretsmanagerInstanceMap and SecretsmanagerInstanceMapOutput values. +// You can construct a concrete instance of `SecretsmanagerInstanceMapInput` via: +// +// SecretsmanagerInstanceMap{ "key": SecretsmanagerInstanceArgs{...} } +type SecretsmanagerInstanceMapInput interface { + pulumi.Input + + ToSecretsmanagerInstanceMapOutput() SecretsmanagerInstanceMapOutput + ToSecretsmanagerInstanceMapOutputWithContext(context.Context) SecretsmanagerInstanceMapOutput +} + +type SecretsmanagerInstanceMap map[string]SecretsmanagerInstanceInput + +func (SecretsmanagerInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecretsmanagerInstance)(nil)).Elem() +} + +func (i SecretsmanagerInstanceMap) ToSecretsmanagerInstanceMapOutput() SecretsmanagerInstanceMapOutput { + return i.ToSecretsmanagerInstanceMapOutputWithContext(context.Background()) +} + +func (i SecretsmanagerInstanceMap) ToSecretsmanagerInstanceMapOutputWithContext(ctx context.Context) SecretsmanagerInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerInstanceMapOutput) +} + +type SecretsmanagerInstanceOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecretsmanagerInstance)(nil)).Elem() +} + +func (o SecretsmanagerInstanceOutput) ToSecretsmanagerInstanceOutput() SecretsmanagerInstanceOutput { + return o +} + +func (o SecretsmanagerInstanceOutput) ToSecretsmanagerInstanceOutputWithContext(ctx context.Context) SecretsmanagerInstanceOutput { + return o +} + +// The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation +func (o SecretsmanagerInstanceOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SecretsmanagerInstance) pulumi.StringArrayOutput { return v.Acls }).(pulumi.StringArrayOutput) +} + +// ID of the Secrets Manager instance. +func (o SecretsmanagerInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o SecretsmanagerInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o SecretsmanagerInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +type SecretsmanagerInstanceArrayOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecretsmanagerInstance)(nil)).Elem() +} + +func (o SecretsmanagerInstanceArrayOutput) ToSecretsmanagerInstanceArrayOutput() SecretsmanagerInstanceArrayOutput { + return o +} + +func (o SecretsmanagerInstanceArrayOutput) ToSecretsmanagerInstanceArrayOutputWithContext(ctx context.Context) SecretsmanagerInstanceArrayOutput { + return o +} + +func (o SecretsmanagerInstanceArrayOutput) Index(i pulumi.IntInput) SecretsmanagerInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecretsmanagerInstance { + return vs[0].([]*SecretsmanagerInstance)[vs[1].(int)] + }).(SecretsmanagerInstanceOutput) +} + +type SecretsmanagerInstanceMapOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecretsmanagerInstance)(nil)).Elem() +} + +func (o SecretsmanagerInstanceMapOutput) ToSecretsmanagerInstanceMapOutput() SecretsmanagerInstanceMapOutput { + return o +} + +func (o SecretsmanagerInstanceMapOutput) ToSecretsmanagerInstanceMapOutputWithContext(ctx context.Context) SecretsmanagerInstanceMapOutput { + return o +} + +func (o SecretsmanagerInstanceMapOutput) MapIndex(k pulumi.StringInput) SecretsmanagerInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecretsmanagerInstance { + return vs[0].(map[string]*SecretsmanagerInstance)[vs[1].(string)] + }).(SecretsmanagerInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerInstanceInput)(nil)).Elem(), &SecretsmanagerInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerInstanceArrayInput)(nil)).Elem(), SecretsmanagerInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerInstanceMapInput)(nil)).Elem(), SecretsmanagerInstanceMap{}) + pulumi.RegisterOutputType(SecretsmanagerInstanceOutput{}) + pulumi.RegisterOutputType(SecretsmanagerInstanceArrayOutput{}) + pulumi.RegisterOutputType(SecretsmanagerInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/secretsmanagerUser.go b/sdk/go/stackit/secretsmanagerUser.go new file mode 100644 index 0000000..b53303f --- /dev/null +++ b/sdk/go/stackit/secretsmanagerUser.go @@ -0,0 +1,312 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Secrets Manager user resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SecretsmanagerUser struct { + pulumi.CustomResourceState + + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description pulumi.StringOutput `pulumi:"description"` + // ID of the Secrets Manager instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // An auto-generated password. + Password pulumi.StringOutput `pulumi:"password"` + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The user's ID. + UserId pulumi.StringOutput `pulumi:"userId"` + // An auto-generated user name. + Username pulumi.StringOutput `pulumi:"username"` + // If true, the user has writeaccess to the secrets engine. + WriteEnabled pulumi.BoolOutput `pulumi:"writeEnabled"` +} + +// NewSecretsmanagerUser registers a new resource with the given unique name, arguments, and options. +func NewSecretsmanagerUser(ctx *pulumi.Context, + name string, args *SecretsmanagerUserArgs, opts ...pulumi.ResourceOption) (*SecretsmanagerUser, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Description == nil { + return nil, errors.New("invalid value for required argument 'Description'") + } + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.WriteEnabled == nil { + return nil, errors.New("invalid value for required argument 'WriteEnabled'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource SecretsmanagerUser + err := ctx.RegisterResource("stackit:index/secretsmanagerUser:SecretsmanagerUser", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSecretsmanagerUser gets an existing SecretsmanagerUser 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 GetSecretsmanagerUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SecretsmanagerUserState, opts ...pulumi.ResourceOption) (*SecretsmanagerUser, error) { + var resource SecretsmanagerUser + err := ctx.ReadResource("stackit:index/secretsmanagerUser:SecretsmanagerUser", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SecretsmanagerUser resources. +type secretsmanagerUserState struct { + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description *string `pulumi:"description"` + // ID of the Secrets Manager instance. + InstanceId *string `pulumi:"instanceId"` + // An auto-generated password. + Password *string `pulumi:"password"` + // STACKIT Project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The user's ID. + UserId *string `pulumi:"userId"` + // An auto-generated user name. + Username *string `pulumi:"username"` + // If true, the user has writeaccess to the secrets engine. + WriteEnabled *bool `pulumi:"writeEnabled"` +} + +type SecretsmanagerUserState struct { + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description pulumi.StringPtrInput + // ID of the Secrets Manager instance. + InstanceId pulumi.StringPtrInput + // An auto-generated password. + Password pulumi.StringPtrInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The user's ID. + UserId pulumi.StringPtrInput + // An auto-generated user name. + Username pulumi.StringPtrInput + // If true, the user has writeaccess to the secrets engine. + WriteEnabled pulumi.BoolPtrInput +} + +func (SecretsmanagerUserState) ElementType() reflect.Type { + return reflect.TypeOf((*secretsmanagerUserState)(nil)).Elem() +} + +type secretsmanagerUserArgs struct { + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description string `pulumi:"description"` + // ID of the Secrets Manager instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT Project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // If true, the user has writeaccess to the secrets engine. + WriteEnabled bool `pulumi:"writeEnabled"` +} + +// The set of arguments for constructing a SecretsmanagerUser resource. +type SecretsmanagerUserArgs struct { + // A user chosen description to differentiate between multiple users. Can't be changed after creation. + Description pulumi.StringInput + // ID of the Secrets Manager instance. + InstanceId pulumi.StringInput + // STACKIT Project ID to which the instance is associated. + ProjectId pulumi.StringInput + // If true, the user has writeaccess to the secrets engine. + WriteEnabled pulumi.BoolInput +} + +func (SecretsmanagerUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*secretsmanagerUserArgs)(nil)).Elem() +} + +type SecretsmanagerUserInput interface { + pulumi.Input + + ToSecretsmanagerUserOutput() SecretsmanagerUserOutput + ToSecretsmanagerUserOutputWithContext(ctx context.Context) SecretsmanagerUserOutput +} + +func (*SecretsmanagerUser) ElementType() reflect.Type { + return reflect.TypeOf((**SecretsmanagerUser)(nil)).Elem() +} + +func (i *SecretsmanagerUser) ToSecretsmanagerUserOutput() SecretsmanagerUserOutput { + return i.ToSecretsmanagerUserOutputWithContext(context.Background()) +} + +func (i *SecretsmanagerUser) ToSecretsmanagerUserOutputWithContext(ctx context.Context) SecretsmanagerUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerUserOutput) +} + +// SecretsmanagerUserArrayInput is an input type that accepts SecretsmanagerUserArray and SecretsmanagerUserArrayOutput values. +// You can construct a concrete instance of `SecretsmanagerUserArrayInput` via: +// +// SecretsmanagerUserArray{ SecretsmanagerUserArgs{...} } +type SecretsmanagerUserArrayInput interface { + pulumi.Input + + ToSecretsmanagerUserArrayOutput() SecretsmanagerUserArrayOutput + ToSecretsmanagerUserArrayOutputWithContext(context.Context) SecretsmanagerUserArrayOutput +} + +type SecretsmanagerUserArray []SecretsmanagerUserInput + +func (SecretsmanagerUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecretsmanagerUser)(nil)).Elem() +} + +func (i SecretsmanagerUserArray) ToSecretsmanagerUserArrayOutput() SecretsmanagerUserArrayOutput { + return i.ToSecretsmanagerUserArrayOutputWithContext(context.Background()) +} + +func (i SecretsmanagerUserArray) ToSecretsmanagerUserArrayOutputWithContext(ctx context.Context) SecretsmanagerUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerUserArrayOutput) +} + +// SecretsmanagerUserMapInput is an input type that accepts SecretsmanagerUserMap and SecretsmanagerUserMapOutput values. +// You can construct a concrete instance of `SecretsmanagerUserMapInput` via: +// +// SecretsmanagerUserMap{ "key": SecretsmanagerUserArgs{...} } +type SecretsmanagerUserMapInput interface { + pulumi.Input + + ToSecretsmanagerUserMapOutput() SecretsmanagerUserMapOutput + ToSecretsmanagerUserMapOutputWithContext(context.Context) SecretsmanagerUserMapOutput +} + +type SecretsmanagerUserMap map[string]SecretsmanagerUserInput + +func (SecretsmanagerUserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecretsmanagerUser)(nil)).Elem() +} + +func (i SecretsmanagerUserMap) ToSecretsmanagerUserMapOutput() SecretsmanagerUserMapOutput { + return i.ToSecretsmanagerUserMapOutputWithContext(context.Background()) +} + +func (i SecretsmanagerUserMap) ToSecretsmanagerUserMapOutputWithContext(ctx context.Context) SecretsmanagerUserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecretsmanagerUserMapOutput) +} + +type SecretsmanagerUserOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecretsmanagerUser)(nil)).Elem() +} + +func (o SecretsmanagerUserOutput) ToSecretsmanagerUserOutput() SecretsmanagerUserOutput { + return o +} + +func (o SecretsmanagerUserOutput) ToSecretsmanagerUserOutputWithContext(ctx context.Context) SecretsmanagerUserOutput { + return o +} + +// A user chosen description to differentiate between multiple users. Can't be changed after creation. +func (o SecretsmanagerUserOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput) +} + +// ID of the Secrets Manager instance. +func (o SecretsmanagerUserOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// An auto-generated password. +func (o SecretsmanagerUserOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the instance is associated. +func (o SecretsmanagerUserOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The user's ID. +func (o SecretsmanagerUserOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.UserId }).(pulumi.StringOutput) +} + +// An auto-generated user name. +func (o SecretsmanagerUserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +// If true, the user has writeaccess to the secrets engine. +func (o SecretsmanagerUserOutput) WriteEnabled() pulumi.BoolOutput { + return o.ApplyT(func(v *SecretsmanagerUser) pulumi.BoolOutput { return v.WriteEnabled }).(pulumi.BoolOutput) +} + +type SecretsmanagerUserArrayOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecretsmanagerUser)(nil)).Elem() +} + +func (o SecretsmanagerUserArrayOutput) ToSecretsmanagerUserArrayOutput() SecretsmanagerUserArrayOutput { + return o +} + +func (o SecretsmanagerUserArrayOutput) ToSecretsmanagerUserArrayOutputWithContext(ctx context.Context) SecretsmanagerUserArrayOutput { + return o +} + +func (o SecretsmanagerUserArrayOutput) Index(i pulumi.IntInput) SecretsmanagerUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecretsmanagerUser { + return vs[0].([]*SecretsmanagerUser)[vs[1].(int)] + }).(SecretsmanagerUserOutput) +} + +type SecretsmanagerUserMapOutput struct{ *pulumi.OutputState } + +func (SecretsmanagerUserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecretsmanagerUser)(nil)).Elem() +} + +func (o SecretsmanagerUserMapOutput) ToSecretsmanagerUserMapOutput() SecretsmanagerUserMapOutput { + return o +} + +func (o SecretsmanagerUserMapOutput) ToSecretsmanagerUserMapOutputWithContext(ctx context.Context) SecretsmanagerUserMapOutput { + return o +} + +func (o SecretsmanagerUserMapOutput) MapIndex(k pulumi.StringInput) SecretsmanagerUserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecretsmanagerUser { + return vs[0].(map[string]*SecretsmanagerUser)[vs[1].(string)] + }).(SecretsmanagerUserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerUserInput)(nil)).Elem(), &SecretsmanagerUser{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerUserArrayInput)(nil)).Elem(), SecretsmanagerUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecretsmanagerUserMapInput)(nil)).Elem(), SecretsmanagerUserMap{}) + pulumi.RegisterOutputType(SecretsmanagerUserOutput{}) + pulumi.RegisterOutputType(SecretsmanagerUserArrayOutput{}) + pulumi.RegisterOutputType(SecretsmanagerUserMapOutput{}) +} diff --git a/sdk/go/stackit/securityGroup.go b/sdk/go/stackit/securityGroup.go new file mode 100644 index 0000000..652b67e --- /dev/null +++ b/sdk/go/stackit/securityGroup.go @@ -0,0 +1,292 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Security group resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SecurityGroup struct { + pulumi.CustomResourceState + + // The description of the security group. + Description pulumi.StringOutput `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The name of the security group. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the security group is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The security group ID. + SecurityGroupId pulumi.StringOutput `pulumi:"securityGroupId"` + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful pulumi.BoolOutput `pulumi:"stateful"` +} + +// NewSecurityGroup registers a new resource with the given unique name, arguments, and options. +func NewSecurityGroup(ctx *pulumi.Context, + name string, args *SecurityGroupArgs, opts ...pulumi.ResourceOption) (*SecurityGroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource SecurityGroup + err := ctx.RegisterResource("stackit:index/securityGroup:SecurityGroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSecurityGroup gets an existing SecurityGroup 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 GetSecurityGroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SecurityGroupState, opts ...pulumi.ResourceOption) (*SecurityGroup, error) { + var resource SecurityGroup + err := ctx.ReadResource("stackit:index/securityGroup:SecurityGroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SecurityGroup resources. +type securityGroupState struct { + // The description of the security group. + Description *string `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the security group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the security group is associated. + ProjectId *string `pulumi:"projectId"` + // The security group ID. + SecurityGroupId *string `pulumi:"securityGroupId"` + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful *bool `pulumi:"stateful"` +} + +type SecurityGroupState struct { + // The description of the security group. + Description pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the security group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the security group is associated. + ProjectId pulumi.StringPtrInput + // The security group ID. + SecurityGroupId pulumi.StringPtrInput + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful pulumi.BoolPtrInput +} + +func (SecurityGroupState) ElementType() reflect.Type { + return reflect.TypeOf((*securityGroupState)(nil)).Elem() +} + +type securityGroupArgs struct { + // The description of the security group. + Description *string `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the security group. + Name *string `pulumi:"name"` + // STACKIT project ID to which the security group is associated. + ProjectId string `pulumi:"projectId"` + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful *bool `pulumi:"stateful"` +} + +// The set of arguments for constructing a SecurityGroup resource. +type SecurityGroupArgs struct { + // The description of the security group. + Description pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the security group. + Name pulumi.StringPtrInput + // STACKIT project ID to which the security group is associated. + ProjectId pulumi.StringInput + // Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + Stateful pulumi.BoolPtrInput +} + +func (SecurityGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*securityGroupArgs)(nil)).Elem() +} + +type SecurityGroupInput interface { + pulumi.Input + + ToSecurityGroupOutput() SecurityGroupOutput + ToSecurityGroupOutputWithContext(ctx context.Context) SecurityGroupOutput +} + +func (*SecurityGroup) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroup)(nil)).Elem() +} + +func (i *SecurityGroup) ToSecurityGroupOutput() SecurityGroupOutput { + return i.ToSecurityGroupOutputWithContext(context.Background()) +} + +func (i *SecurityGroup) ToSecurityGroupOutputWithContext(ctx context.Context) SecurityGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupOutput) +} + +// SecurityGroupArrayInput is an input type that accepts SecurityGroupArray and SecurityGroupArrayOutput values. +// You can construct a concrete instance of `SecurityGroupArrayInput` via: +// +// SecurityGroupArray{ SecurityGroupArgs{...} } +type SecurityGroupArrayInput interface { + pulumi.Input + + ToSecurityGroupArrayOutput() SecurityGroupArrayOutput + ToSecurityGroupArrayOutputWithContext(context.Context) SecurityGroupArrayOutput +} + +type SecurityGroupArray []SecurityGroupInput + +func (SecurityGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecurityGroup)(nil)).Elem() +} + +func (i SecurityGroupArray) ToSecurityGroupArrayOutput() SecurityGroupArrayOutput { + return i.ToSecurityGroupArrayOutputWithContext(context.Background()) +} + +func (i SecurityGroupArray) ToSecurityGroupArrayOutputWithContext(ctx context.Context) SecurityGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupArrayOutput) +} + +// SecurityGroupMapInput is an input type that accepts SecurityGroupMap and SecurityGroupMapOutput values. +// You can construct a concrete instance of `SecurityGroupMapInput` via: +// +// SecurityGroupMap{ "key": SecurityGroupArgs{...} } +type SecurityGroupMapInput interface { + pulumi.Input + + ToSecurityGroupMapOutput() SecurityGroupMapOutput + ToSecurityGroupMapOutputWithContext(context.Context) SecurityGroupMapOutput +} + +type SecurityGroupMap map[string]SecurityGroupInput + +func (SecurityGroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecurityGroup)(nil)).Elem() +} + +func (i SecurityGroupMap) ToSecurityGroupMapOutput() SecurityGroupMapOutput { + return i.ToSecurityGroupMapOutputWithContext(context.Background()) +} + +func (i SecurityGroupMap) ToSecurityGroupMapOutputWithContext(ctx context.Context) SecurityGroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupMapOutput) +} + +type SecurityGroupOutput struct{ *pulumi.OutputState } + +func (SecurityGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroup)(nil)).Elem() +} + +func (o SecurityGroupOutput) ToSecurityGroupOutput() SecurityGroupOutput { + return o +} + +func (o SecurityGroupOutput) ToSecurityGroupOutputWithContext(ctx context.Context) SecurityGroupOutput { + return o +} + +// The description of the security group. +func (o SecurityGroupOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o SecurityGroupOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the security group. +func (o SecurityGroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the security group is associated. +func (o SecurityGroupOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The security group ID. +func (o SecurityGroupOutput) SecurityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.StringOutput { return v.SecurityGroupId }).(pulumi.StringOutput) +} + +// Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. +func (o SecurityGroupOutput) Stateful() pulumi.BoolOutput { + return o.ApplyT(func(v *SecurityGroup) pulumi.BoolOutput { return v.Stateful }).(pulumi.BoolOutput) +} + +type SecurityGroupArrayOutput struct{ *pulumi.OutputState } + +func (SecurityGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecurityGroup)(nil)).Elem() +} + +func (o SecurityGroupArrayOutput) ToSecurityGroupArrayOutput() SecurityGroupArrayOutput { + return o +} + +func (o SecurityGroupArrayOutput) ToSecurityGroupArrayOutputWithContext(ctx context.Context) SecurityGroupArrayOutput { + return o +} + +func (o SecurityGroupArrayOutput) Index(i pulumi.IntInput) SecurityGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecurityGroup { + return vs[0].([]*SecurityGroup)[vs[1].(int)] + }).(SecurityGroupOutput) +} + +type SecurityGroupMapOutput struct{ *pulumi.OutputState } + +func (SecurityGroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecurityGroup)(nil)).Elem() +} + +func (o SecurityGroupMapOutput) ToSecurityGroupMapOutput() SecurityGroupMapOutput { + return o +} + +func (o SecurityGroupMapOutput) ToSecurityGroupMapOutputWithContext(ctx context.Context) SecurityGroupMapOutput { + return o +} + +func (o SecurityGroupMapOutput) MapIndex(k pulumi.StringInput) SecurityGroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecurityGroup { + return vs[0].(map[string]*SecurityGroup)[vs[1].(string)] + }).(SecurityGroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupInput)(nil)).Elem(), &SecurityGroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupArrayInput)(nil)).Elem(), SecurityGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupMapInput)(nil)).Elem(), SecurityGroupMap{}) + pulumi.RegisterOutputType(SecurityGroupOutput{}) + pulumi.RegisterOutputType(SecurityGroupArrayOutput{}) + pulumi.RegisterOutputType(SecurityGroupMapOutput{}) +} diff --git a/sdk/go/stackit/securityGroupRule.go b/sdk/go/stackit/securityGroupRule.go new file mode 100644 index 0000000..4dfe771 --- /dev/null +++ b/sdk/go/stackit/securityGroupRule.go @@ -0,0 +1,373 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Security group rule resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SecurityGroupRule struct { + pulumi.CustomResourceState + + // The rule description. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction pulumi.StringOutput `pulumi:"direction"` + // The ethertype which the rule should match. + EtherType pulumi.StringOutput `pulumi:"etherType"` + // ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + IcmpParameters SecurityGroupRuleIcmpParametersOutput `pulumi:"icmpParameters"` + // The remote IP range which the rule should match. + IpRange pulumi.StringPtrOutput `pulumi:"ipRange"` + // The range of ports. This should only be provided if the protocol is not ICMP. + PortRange SecurityGroupRulePortRangeOutput `pulumi:"portRange"` + // STACKIT project ID to which the security group rule is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The internet protocol which the rule should match. + Protocol SecurityGroupRuleProtocolOutput `pulumi:"protocol"` + // The remote security group which the rule should match. + RemoteSecurityGroupId pulumi.StringPtrOutput `pulumi:"remoteSecurityGroupId"` + // The security group ID. + SecurityGroupId pulumi.StringOutput `pulumi:"securityGroupId"` + // The security group rule ID. + SecurityGroupRuleId pulumi.StringOutput `pulumi:"securityGroupRuleId"` +} + +// NewSecurityGroupRule registers a new resource with the given unique name, arguments, and options. +func NewSecurityGroupRule(ctx *pulumi.Context, + name string, args *SecurityGroupRuleArgs, opts ...pulumi.ResourceOption) (*SecurityGroupRule, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Direction == nil { + return nil, errors.New("invalid value for required argument 'Direction'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.SecurityGroupId == nil { + return nil, errors.New("invalid value for required argument 'SecurityGroupId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource SecurityGroupRule + err := ctx.RegisterResource("stackit:index/securityGroupRule:SecurityGroupRule", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSecurityGroupRule gets an existing SecurityGroupRule 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 GetSecurityGroupRule(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SecurityGroupRuleState, opts ...pulumi.ResourceOption) (*SecurityGroupRule, error) { + var resource SecurityGroupRule + err := ctx.ReadResource("stackit:index/securityGroupRule:SecurityGroupRule", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SecurityGroupRule resources. +type securityGroupRuleState struct { + // The rule description. + Description *string `pulumi:"description"` + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction *string `pulumi:"direction"` + // The ethertype which the rule should match. + EtherType *string `pulumi:"etherType"` + // ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + IcmpParameters *SecurityGroupRuleIcmpParameters `pulumi:"icmpParameters"` + // The remote IP range which the rule should match. + IpRange *string `pulumi:"ipRange"` + // The range of ports. This should only be provided if the protocol is not ICMP. + PortRange *SecurityGroupRulePortRange `pulumi:"portRange"` + // STACKIT project ID to which the security group rule is associated. + ProjectId *string `pulumi:"projectId"` + // The internet protocol which the rule should match. + Protocol *SecurityGroupRuleProtocol `pulumi:"protocol"` + // The remote security group which the rule should match. + RemoteSecurityGroupId *string `pulumi:"remoteSecurityGroupId"` + // The security group ID. + SecurityGroupId *string `pulumi:"securityGroupId"` + // The security group rule ID. + SecurityGroupRuleId *string `pulumi:"securityGroupRuleId"` +} + +type SecurityGroupRuleState struct { + // The rule description. + Description pulumi.StringPtrInput + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction pulumi.StringPtrInput + // The ethertype which the rule should match. + EtherType pulumi.StringPtrInput + // ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + IcmpParameters SecurityGroupRuleIcmpParametersPtrInput + // The remote IP range which the rule should match. + IpRange pulumi.StringPtrInput + // The range of ports. This should only be provided if the protocol is not ICMP. + PortRange SecurityGroupRulePortRangePtrInput + // STACKIT project ID to which the security group rule is associated. + ProjectId pulumi.StringPtrInput + // The internet protocol which the rule should match. + Protocol SecurityGroupRuleProtocolPtrInput + // The remote security group which the rule should match. + RemoteSecurityGroupId pulumi.StringPtrInput + // The security group ID. + SecurityGroupId pulumi.StringPtrInput + // The security group rule ID. + SecurityGroupRuleId pulumi.StringPtrInput +} + +func (SecurityGroupRuleState) ElementType() reflect.Type { + return reflect.TypeOf((*securityGroupRuleState)(nil)).Elem() +} + +type securityGroupRuleArgs struct { + // The rule description. + Description *string `pulumi:"description"` + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction string `pulumi:"direction"` + // The ethertype which the rule should match. + EtherType *string `pulumi:"etherType"` + // ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + IcmpParameters *SecurityGroupRuleIcmpParameters `pulumi:"icmpParameters"` + // The remote IP range which the rule should match. + IpRange *string `pulumi:"ipRange"` + // The range of ports. This should only be provided if the protocol is not ICMP. + PortRange *SecurityGroupRulePortRange `pulumi:"portRange"` + // STACKIT project ID to which the security group rule is associated. + ProjectId string `pulumi:"projectId"` + // The internet protocol which the rule should match. + Protocol *SecurityGroupRuleProtocol `pulumi:"protocol"` + // The remote security group which the rule should match. + RemoteSecurityGroupId *string `pulumi:"remoteSecurityGroupId"` + // The security group ID. + SecurityGroupId string `pulumi:"securityGroupId"` +} + +// The set of arguments for constructing a SecurityGroupRule resource. +type SecurityGroupRuleArgs struct { + // The rule description. + Description pulumi.StringPtrInput + // The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + Direction pulumi.StringInput + // The ethertype which the rule should match. + EtherType pulumi.StringPtrInput + // ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + IcmpParameters SecurityGroupRuleIcmpParametersPtrInput + // The remote IP range which the rule should match. + IpRange pulumi.StringPtrInput + // The range of ports. This should only be provided if the protocol is not ICMP. + PortRange SecurityGroupRulePortRangePtrInput + // STACKIT project ID to which the security group rule is associated. + ProjectId pulumi.StringInput + // The internet protocol which the rule should match. + Protocol SecurityGroupRuleProtocolPtrInput + // The remote security group which the rule should match. + RemoteSecurityGroupId pulumi.StringPtrInput + // The security group ID. + SecurityGroupId pulumi.StringInput +} + +func (SecurityGroupRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*securityGroupRuleArgs)(nil)).Elem() +} + +type SecurityGroupRuleInput interface { + pulumi.Input + + ToSecurityGroupRuleOutput() SecurityGroupRuleOutput + ToSecurityGroupRuleOutputWithContext(ctx context.Context) SecurityGroupRuleOutput +} + +func (*SecurityGroupRule) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRule)(nil)).Elem() +} + +func (i *SecurityGroupRule) ToSecurityGroupRuleOutput() SecurityGroupRuleOutput { + return i.ToSecurityGroupRuleOutputWithContext(context.Background()) +} + +func (i *SecurityGroupRule) ToSecurityGroupRuleOutputWithContext(ctx context.Context) SecurityGroupRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleOutput) +} + +// SecurityGroupRuleArrayInput is an input type that accepts SecurityGroupRuleArray and SecurityGroupRuleArrayOutput values. +// You can construct a concrete instance of `SecurityGroupRuleArrayInput` via: +// +// SecurityGroupRuleArray{ SecurityGroupRuleArgs{...} } +type SecurityGroupRuleArrayInput interface { + pulumi.Input + + ToSecurityGroupRuleArrayOutput() SecurityGroupRuleArrayOutput + ToSecurityGroupRuleArrayOutputWithContext(context.Context) SecurityGroupRuleArrayOutput +} + +type SecurityGroupRuleArray []SecurityGroupRuleInput + +func (SecurityGroupRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecurityGroupRule)(nil)).Elem() +} + +func (i SecurityGroupRuleArray) ToSecurityGroupRuleArrayOutput() SecurityGroupRuleArrayOutput { + return i.ToSecurityGroupRuleArrayOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleArray) ToSecurityGroupRuleArrayOutputWithContext(ctx context.Context) SecurityGroupRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleArrayOutput) +} + +// SecurityGroupRuleMapInput is an input type that accepts SecurityGroupRuleMap and SecurityGroupRuleMapOutput values. +// You can construct a concrete instance of `SecurityGroupRuleMapInput` via: +// +// SecurityGroupRuleMap{ "key": SecurityGroupRuleArgs{...} } +type SecurityGroupRuleMapInput interface { + pulumi.Input + + ToSecurityGroupRuleMapOutput() SecurityGroupRuleMapOutput + ToSecurityGroupRuleMapOutputWithContext(context.Context) SecurityGroupRuleMapOutput +} + +type SecurityGroupRuleMap map[string]SecurityGroupRuleInput + +func (SecurityGroupRuleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecurityGroupRule)(nil)).Elem() +} + +func (i SecurityGroupRuleMap) ToSecurityGroupRuleMapOutput() SecurityGroupRuleMapOutput { + return i.ToSecurityGroupRuleMapOutputWithContext(context.Background()) +} + +func (i SecurityGroupRuleMap) ToSecurityGroupRuleMapOutputWithContext(ctx context.Context) SecurityGroupRuleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SecurityGroupRuleMapOutput) +} + +type SecurityGroupRuleOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SecurityGroupRule)(nil)).Elem() +} + +func (o SecurityGroupRuleOutput) ToSecurityGroupRuleOutput() SecurityGroupRuleOutput { + return o +} + +func (o SecurityGroupRuleOutput) ToSecurityGroupRuleOutputWithContext(ctx context.Context) SecurityGroupRuleOutput { + return o +} + +// The rule description. +func (o SecurityGroupRuleOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. +func (o SecurityGroupRuleOutput) Direction() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringOutput { return v.Direction }).(pulumi.StringOutput) +} + +// The ethertype which the rule should match. +func (o SecurityGroupRuleOutput) EtherType() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringOutput { return v.EtherType }).(pulumi.StringOutput) +} + +// ICMP Parameters. These parameters should only be provided if the protocol is ICMP. +func (o SecurityGroupRuleOutput) IcmpParameters() SecurityGroupRuleIcmpParametersOutput { + return o.ApplyT(func(v *SecurityGroupRule) SecurityGroupRuleIcmpParametersOutput { return v.IcmpParameters }).(SecurityGroupRuleIcmpParametersOutput) +} + +// The remote IP range which the rule should match. +func (o SecurityGroupRuleOutput) IpRange() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringPtrOutput { return v.IpRange }).(pulumi.StringPtrOutput) +} + +// The range of ports. This should only be provided if the protocol is not ICMP. +func (o SecurityGroupRuleOutput) PortRange() SecurityGroupRulePortRangeOutput { + return o.ApplyT(func(v *SecurityGroupRule) SecurityGroupRulePortRangeOutput { return v.PortRange }).(SecurityGroupRulePortRangeOutput) +} + +// STACKIT project ID to which the security group rule is associated. +func (o SecurityGroupRuleOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The internet protocol which the rule should match. +func (o SecurityGroupRuleOutput) Protocol() SecurityGroupRuleProtocolOutput { + return o.ApplyT(func(v *SecurityGroupRule) SecurityGroupRuleProtocolOutput { return v.Protocol }).(SecurityGroupRuleProtocolOutput) +} + +// The remote security group which the rule should match. +func (o SecurityGroupRuleOutput) RemoteSecurityGroupId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringPtrOutput { return v.RemoteSecurityGroupId }).(pulumi.StringPtrOutput) +} + +// The security group ID. +func (o SecurityGroupRuleOutput) SecurityGroupId() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringOutput { return v.SecurityGroupId }).(pulumi.StringOutput) +} + +// The security group rule ID. +func (o SecurityGroupRuleOutput) SecurityGroupRuleId() pulumi.StringOutput { + return o.ApplyT(func(v *SecurityGroupRule) pulumi.StringOutput { return v.SecurityGroupRuleId }).(pulumi.StringOutput) +} + +type SecurityGroupRuleArrayOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SecurityGroupRule)(nil)).Elem() +} + +func (o SecurityGroupRuleArrayOutput) ToSecurityGroupRuleArrayOutput() SecurityGroupRuleArrayOutput { + return o +} + +func (o SecurityGroupRuleArrayOutput) ToSecurityGroupRuleArrayOutputWithContext(ctx context.Context) SecurityGroupRuleArrayOutput { + return o +} + +func (o SecurityGroupRuleArrayOutput) Index(i pulumi.IntInput) SecurityGroupRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SecurityGroupRule { + return vs[0].([]*SecurityGroupRule)[vs[1].(int)] + }).(SecurityGroupRuleOutput) +} + +type SecurityGroupRuleMapOutput struct{ *pulumi.OutputState } + +func (SecurityGroupRuleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SecurityGroupRule)(nil)).Elem() +} + +func (o SecurityGroupRuleMapOutput) ToSecurityGroupRuleMapOutput() SecurityGroupRuleMapOutput { + return o +} + +func (o SecurityGroupRuleMapOutput) ToSecurityGroupRuleMapOutputWithContext(ctx context.Context) SecurityGroupRuleMapOutput { + return o +} + +func (o SecurityGroupRuleMapOutput) MapIndex(k pulumi.StringInput) SecurityGroupRuleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SecurityGroupRule { + return vs[0].(map[string]*SecurityGroupRule)[vs[1].(string)] + }).(SecurityGroupRuleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleInput)(nil)).Elem(), &SecurityGroupRule{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleArrayInput)(nil)).Elem(), SecurityGroupRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SecurityGroupRuleMapInput)(nil)).Elem(), SecurityGroupRuleMap{}) + pulumi.RegisterOutputType(SecurityGroupRuleOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleArrayOutput{}) + pulumi.RegisterOutputType(SecurityGroupRuleMapOutput{}) +} diff --git a/sdk/go/stackit/server.go b/sdk/go/stackit/server.go new file mode 100644 index 0000000..494fb92 --- /dev/null +++ b/sdk/go/stackit/server.go @@ -0,0 +1,445 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server resource schema. Must have a region specified in the provider configuration. +// +// ## Example Usage +// +// ### With key pair +// +// ### Boot from volume +// +// ### Boot from existing volume +// +// ### Network setup +// +// ### Server with attached volume +// +// ### Server with user data (cloud-init) +type Server struct { + pulumi.CustomResourceState + + // The affinity group the server is assigned to. + AffinityGroup pulumi.StringPtrOutput `pulumi:"affinityGroup"` + // The availability zone of the server. + AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"` + // The boot volume for the server + BootVolume ServerBootVolumePtrOutput `pulumi:"bootVolume"` + // Date-time when the server was created + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + DesiredStatus pulumi.StringPtrOutput `pulumi:"desiredStatus"` + // The image ID to be used for an ephemeral disk on the server. + ImageId pulumi.StringPtrOutput `pulumi:"imageId"` + // The name of the keypair used during server creation. + KeypairName pulumi.StringPtrOutput `pulumi:"keypairName"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // Date-time when the server was launched + LaunchedAt pulumi.StringOutput `pulumi:"launchedAt"` + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType pulumi.StringOutput `pulumi:"machineType"` + // The name of the server. + Name pulumi.StringOutput `pulumi:"name"` + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces pulumi.StringArrayOutput `pulumi:"networkInterfaces"` + // STACKIT project ID to which the server is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The server ID. + ServerId pulumi.StringOutput `pulumi:"serverId"` + // Date-time when the server was updated + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // User data that is passed via cloud-init to the server. + UserData pulumi.StringPtrOutput `pulumi:"userData"` +} + +// NewServer registers a new resource with the given unique name, arguments, and options. +func NewServer(ctx *pulumi.Context, + name string, args *ServerArgs, opts ...pulumi.ResourceOption) (*Server, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.MachineType == nil { + return nil, errors.New("invalid value for required argument 'MachineType'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Server + err := ctx.RegisterResource("stackit:index/server:Server", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServer gets an existing Server 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 GetServer(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerState, opts ...pulumi.ResourceOption) (*Server, error) { + var resource Server + err := ctx.ReadResource("stackit:index/server:Server", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Server resources. +type serverState struct { + // The affinity group the server is assigned to. + AffinityGroup *string `pulumi:"affinityGroup"` + // The availability zone of the server. + AvailabilityZone *string `pulumi:"availabilityZone"` + // The boot volume for the server + BootVolume *ServerBootVolume `pulumi:"bootVolume"` + // Date-time when the server was created + CreatedAt *string `pulumi:"createdAt"` + // The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + DesiredStatus *string `pulumi:"desiredStatus"` + // The image ID to be used for an ephemeral disk on the server. + ImageId *string `pulumi:"imageId"` + // The name of the keypair used during server creation. + KeypairName *string `pulumi:"keypairName"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // Date-time when the server was launched + LaunchedAt *string `pulumi:"launchedAt"` + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType *string `pulumi:"machineType"` + // The name of the server. + Name *string `pulumi:"name"` + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces []string `pulumi:"networkInterfaces"` + // STACKIT project ID to which the server is associated. + ProjectId *string `pulumi:"projectId"` + // The server ID. + ServerId *string `pulumi:"serverId"` + // Date-time when the server was updated + UpdatedAt *string `pulumi:"updatedAt"` + // User data that is passed via cloud-init to the server. + UserData *string `pulumi:"userData"` +} + +type ServerState struct { + // The affinity group the server is assigned to. + AffinityGroup pulumi.StringPtrInput + // The availability zone of the server. + AvailabilityZone pulumi.StringPtrInput + // The boot volume for the server + BootVolume ServerBootVolumePtrInput + // Date-time when the server was created + CreatedAt pulumi.StringPtrInput + // The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + DesiredStatus pulumi.StringPtrInput + // The image ID to be used for an ephemeral disk on the server. + ImageId pulumi.StringPtrInput + // The name of the keypair used during server creation. + KeypairName pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // Date-time when the server was launched + LaunchedAt pulumi.StringPtrInput + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType pulumi.StringPtrInput + // The name of the server. + Name pulumi.StringPtrInput + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces pulumi.StringArrayInput + // STACKIT project ID to which the server is associated. + ProjectId pulumi.StringPtrInput + // The server ID. + ServerId pulumi.StringPtrInput + // Date-time when the server was updated + UpdatedAt pulumi.StringPtrInput + // User data that is passed via cloud-init to the server. + UserData pulumi.StringPtrInput +} + +func (ServerState) ElementType() reflect.Type { + return reflect.TypeOf((*serverState)(nil)).Elem() +} + +type serverArgs struct { + // The affinity group the server is assigned to. + AffinityGroup *string `pulumi:"affinityGroup"` + // The availability zone of the server. + AvailabilityZone *string `pulumi:"availabilityZone"` + // The boot volume for the server + BootVolume *ServerBootVolume `pulumi:"bootVolume"` + // The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + DesiredStatus *string `pulumi:"desiredStatus"` + // The image ID to be used for an ephemeral disk on the server. + ImageId *string `pulumi:"imageId"` + // The name of the keypair used during server creation. + KeypairName *string `pulumi:"keypairName"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType string `pulumi:"machineType"` + // The name of the server. + Name *string `pulumi:"name"` + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces []string `pulumi:"networkInterfaces"` + // STACKIT project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // User data that is passed via cloud-init to the server. + UserData *string `pulumi:"userData"` +} + +// The set of arguments for constructing a Server resource. +type ServerArgs struct { + // The affinity group the server is assigned to. + AffinityGroup pulumi.StringPtrInput + // The availability zone of the server. + AvailabilityZone pulumi.StringPtrInput + // The boot volume for the server + BootVolume ServerBootVolumePtrInput + // The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + DesiredStatus pulumi.StringPtrInput + // The image ID to be used for an ephemeral disk on the server. + ImageId pulumi.StringPtrInput + // The name of the keypair used during server creation. + KeypairName pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + MachineType pulumi.StringInput + // The name of the server. + Name pulumi.StringPtrInput + // The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + NetworkInterfaces pulumi.StringArrayInput + // STACKIT project ID to which the server is associated. + ProjectId pulumi.StringInput + // User data that is passed via cloud-init to the server. + UserData pulumi.StringPtrInput +} + +func (ServerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverArgs)(nil)).Elem() +} + +type ServerInput interface { + pulumi.Input + + ToServerOutput() ServerOutput + ToServerOutputWithContext(ctx context.Context) ServerOutput +} + +func (*Server) ElementType() reflect.Type { + return reflect.TypeOf((**Server)(nil)).Elem() +} + +func (i *Server) ToServerOutput() ServerOutput { + return i.ToServerOutputWithContext(context.Background()) +} + +func (i *Server) ToServerOutputWithContext(ctx context.Context) ServerOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerOutput) +} + +// ServerArrayInput is an input type that accepts ServerArray and ServerArrayOutput values. +// You can construct a concrete instance of `ServerArrayInput` via: +// +// ServerArray{ ServerArgs{...} } +type ServerArrayInput interface { + pulumi.Input + + ToServerArrayOutput() ServerArrayOutput + ToServerArrayOutputWithContext(context.Context) ServerArrayOutput +} + +type ServerArray []ServerInput + +func (ServerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Server)(nil)).Elem() +} + +func (i ServerArray) ToServerArrayOutput() ServerArrayOutput { + return i.ToServerArrayOutputWithContext(context.Background()) +} + +func (i ServerArray) ToServerArrayOutputWithContext(ctx context.Context) ServerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerArrayOutput) +} + +// ServerMapInput is an input type that accepts ServerMap and ServerMapOutput values. +// You can construct a concrete instance of `ServerMapInput` via: +// +// ServerMap{ "key": ServerArgs{...} } +type ServerMapInput interface { + pulumi.Input + + ToServerMapOutput() ServerMapOutput + ToServerMapOutputWithContext(context.Context) ServerMapOutput +} + +type ServerMap map[string]ServerInput + +func (ServerMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Server)(nil)).Elem() +} + +func (i ServerMap) ToServerMapOutput() ServerMapOutput { + return i.ToServerMapOutputWithContext(context.Background()) +} + +func (i ServerMap) ToServerMapOutputWithContext(ctx context.Context) ServerMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerMapOutput) +} + +type ServerOutput struct{ *pulumi.OutputState } + +func (ServerOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Server)(nil)).Elem() +} + +func (o ServerOutput) ToServerOutput() ServerOutput { + return o +} + +func (o ServerOutput) ToServerOutputWithContext(ctx context.Context) ServerOutput { + return o +} + +// The affinity group the server is assigned to. +func (o ServerOutput) AffinityGroup() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Server) pulumi.StringPtrOutput { return v.AffinityGroup }).(pulumi.StringPtrOutput) +} + +// The availability zone of the server. +func (o ServerOutput) AvailabilityZone() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.AvailabilityZone }).(pulumi.StringOutput) +} + +// The boot volume for the server +func (o ServerOutput) BootVolume() ServerBootVolumePtrOutput { + return o.ApplyT(func(v *Server) ServerBootVolumePtrOutput { return v.BootVolume }).(ServerBootVolumePtrOutput) +} + +// Date-time when the server was created +func (o ServerOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. +func (o ServerOutput) DesiredStatus() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Server) pulumi.StringPtrOutput { return v.DesiredStatus }).(pulumi.StringPtrOutput) +} + +// The image ID to be used for an ephemeral disk on the server. +func (o ServerOutput) ImageId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Server) pulumi.StringPtrOutput { return v.ImageId }).(pulumi.StringPtrOutput) +} + +// The name of the keypair used during server creation. +func (o ServerOutput) KeypairName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Server) pulumi.StringPtrOutput { return v.KeypairName }).(pulumi.StringPtrOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o ServerOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *Server) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// Date-time when the server was launched +func (o ServerOutput) LaunchedAt() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.LaunchedAt }).(pulumi.StringOutput) +} + +// Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) +func (o ServerOutput) MachineType() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.MachineType }).(pulumi.StringOutput) +} + +// The name of the server. +func (o ServerOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. +func (o ServerOutput) NetworkInterfaces() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Server) pulumi.StringArrayOutput { return v.NetworkInterfaces }).(pulumi.StringArrayOutput) +} + +// STACKIT project ID to which the server is associated. +func (o ServerOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID. +func (o ServerOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +// Date-time when the server was updated +func (o ServerOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *Server) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// User data that is passed via cloud-init to the server. +func (o ServerOutput) UserData() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Server) pulumi.StringPtrOutput { return v.UserData }).(pulumi.StringPtrOutput) +} + +type ServerArrayOutput struct{ *pulumi.OutputState } + +func (ServerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Server)(nil)).Elem() +} + +func (o ServerArrayOutput) ToServerArrayOutput() ServerArrayOutput { + return o +} + +func (o ServerArrayOutput) ToServerArrayOutputWithContext(ctx context.Context) ServerArrayOutput { + return o +} + +func (o ServerArrayOutput) Index(i pulumi.IntInput) ServerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Server { + return vs[0].([]*Server)[vs[1].(int)] + }).(ServerOutput) +} + +type ServerMapOutput struct{ *pulumi.OutputState } + +func (ServerMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Server)(nil)).Elem() +} + +func (o ServerMapOutput) ToServerMapOutput() ServerMapOutput { + return o +} + +func (o ServerMapOutput) ToServerMapOutputWithContext(ctx context.Context) ServerMapOutput { + return o +} + +func (o ServerMapOutput) MapIndex(k pulumi.StringInput) ServerOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Server { + return vs[0].(map[string]*Server)[vs[1].(string)] + }).(ServerOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerInput)(nil)).Elem(), &Server{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerArrayInput)(nil)).Elem(), ServerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerMapInput)(nil)).Elem(), ServerMap{}) + pulumi.RegisterOutputType(ServerOutput{}) + pulumi.RegisterOutputType(ServerArrayOutput{}) + pulumi.RegisterOutputType(ServerMapOutput{}) +} diff --git a/sdk/go/stackit/serverBackupSchedule.go b/sdk/go/stackit/serverBackupSchedule.go new file mode 100644 index 0000000..bd1df41 --- /dev/null +++ b/sdk/go/stackit/serverBackupSchedule.go @@ -0,0 +1,336 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server backup schedule resource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +type ServerBackupSchedule struct { + pulumi.CustomResourceState + + // Backup schedule details for the backups. + BackupProperties ServerBackupScheduleBackupPropertiesOutput `pulumi:"backupProperties"` + // Backup schedule ID. + BackupScheduleId pulumi.IntOutput `pulumi:"backupScheduleId"` + // Is the backup schedule enabled or disabled. + Enabled pulumi.BoolOutput `pulumi:"enabled"` + // The schedule name. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringOutput `pulumi:"rrule"` + // Server ID for the backup schedule. + ServerId pulumi.StringOutput `pulumi:"serverId"` +} + +// NewServerBackupSchedule registers a new resource with the given unique name, arguments, and options. +func NewServerBackupSchedule(ctx *pulumi.Context, + name string, args *ServerBackupScheduleArgs, opts ...pulumi.ResourceOption) (*ServerBackupSchedule, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.BackupProperties == nil { + return nil, errors.New("invalid value for required argument 'BackupProperties'") + } + if args.Enabled == nil { + return nil, errors.New("invalid value for required argument 'Enabled'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Rrule == nil { + return nil, errors.New("invalid value for required argument 'Rrule'") + } + if args.ServerId == nil { + return nil, errors.New("invalid value for required argument 'ServerId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServerBackupSchedule + err := ctx.RegisterResource("stackit:index/serverBackupSchedule:ServerBackupSchedule", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServerBackupSchedule gets an existing ServerBackupSchedule 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 GetServerBackupSchedule(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerBackupScheduleState, opts ...pulumi.ResourceOption) (*ServerBackupSchedule, error) { + var resource ServerBackupSchedule + err := ctx.ReadResource("stackit:index/serverBackupSchedule:ServerBackupSchedule", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServerBackupSchedule resources. +type serverBackupScheduleState struct { + // Backup schedule details for the backups. + BackupProperties *ServerBackupScheduleBackupProperties `pulumi:"backupProperties"` + // Backup schedule ID. + BackupScheduleId *int `pulumi:"backupScheduleId"` + // Is the backup schedule enabled or disabled. + Enabled *bool `pulumi:"enabled"` + // The schedule name. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule *string `pulumi:"rrule"` + // Server ID for the backup schedule. + ServerId *string `pulumi:"serverId"` +} + +type ServerBackupScheduleState struct { + // Backup schedule details for the backups. + BackupProperties ServerBackupScheduleBackupPropertiesPtrInput + // Backup schedule ID. + BackupScheduleId pulumi.IntPtrInput + // Is the backup schedule enabled or disabled. + Enabled pulumi.BoolPtrInput + // The schedule name. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringPtrInput + // Server ID for the backup schedule. + ServerId pulumi.StringPtrInput +} + +func (ServerBackupScheduleState) ElementType() reflect.Type { + return reflect.TypeOf((*serverBackupScheduleState)(nil)).Elem() +} + +type serverBackupScheduleArgs struct { + // Backup schedule details for the backups. + BackupProperties ServerBackupScheduleBackupProperties `pulumi:"backupProperties"` + // Is the backup schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + // The schedule name. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` + // Server ID for the backup schedule. + ServerId string `pulumi:"serverId"` +} + +// The set of arguments for constructing a ServerBackupSchedule resource. +type ServerBackupScheduleArgs struct { + // Backup schedule details for the backups. + BackupProperties ServerBackupScheduleBackupPropertiesInput + // Is the backup schedule enabled or disabled. + Enabled pulumi.BoolInput + // The schedule name. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Backup schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringInput + // Server ID for the backup schedule. + ServerId pulumi.StringInput +} + +func (ServerBackupScheduleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverBackupScheduleArgs)(nil)).Elem() +} + +type ServerBackupScheduleInput interface { + pulumi.Input + + ToServerBackupScheduleOutput() ServerBackupScheduleOutput + ToServerBackupScheduleOutputWithContext(ctx context.Context) ServerBackupScheduleOutput +} + +func (*ServerBackupSchedule) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBackupSchedule)(nil)).Elem() +} + +func (i *ServerBackupSchedule) ToServerBackupScheduleOutput() ServerBackupScheduleOutput { + return i.ToServerBackupScheduleOutputWithContext(context.Background()) +} + +func (i *ServerBackupSchedule) ToServerBackupScheduleOutputWithContext(ctx context.Context) ServerBackupScheduleOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleOutput) +} + +// ServerBackupScheduleArrayInput is an input type that accepts ServerBackupScheduleArray and ServerBackupScheduleArrayOutput values. +// You can construct a concrete instance of `ServerBackupScheduleArrayInput` via: +// +// ServerBackupScheduleArray{ ServerBackupScheduleArgs{...} } +type ServerBackupScheduleArrayInput interface { + pulumi.Input + + ToServerBackupScheduleArrayOutput() ServerBackupScheduleArrayOutput + ToServerBackupScheduleArrayOutputWithContext(context.Context) ServerBackupScheduleArrayOutput +} + +type ServerBackupScheduleArray []ServerBackupScheduleInput + +func (ServerBackupScheduleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerBackupSchedule)(nil)).Elem() +} + +func (i ServerBackupScheduleArray) ToServerBackupScheduleArrayOutput() ServerBackupScheduleArrayOutput { + return i.ToServerBackupScheduleArrayOutputWithContext(context.Background()) +} + +func (i ServerBackupScheduleArray) ToServerBackupScheduleArrayOutputWithContext(ctx context.Context) ServerBackupScheduleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleArrayOutput) +} + +// ServerBackupScheduleMapInput is an input type that accepts ServerBackupScheduleMap and ServerBackupScheduleMapOutput values. +// You can construct a concrete instance of `ServerBackupScheduleMapInput` via: +// +// ServerBackupScheduleMap{ "key": ServerBackupScheduleArgs{...} } +type ServerBackupScheduleMapInput interface { + pulumi.Input + + ToServerBackupScheduleMapOutput() ServerBackupScheduleMapOutput + ToServerBackupScheduleMapOutputWithContext(context.Context) ServerBackupScheduleMapOutput +} + +type ServerBackupScheduleMap map[string]ServerBackupScheduleInput + +func (ServerBackupScheduleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerBackupSchedule)(nil)).Elem() +} + +func (i ServerBackupScheduleMap) ToServerBackupScheduleMapOutput() ServerBackupScheduleMapOutput { + return i.ToServerBackupScheduleMapOutputWithContext(context.Background()) +} + +func (i ServerBackupScheduleMap) ToServerBackupScheduleMapOutputWithContext(ctx context.Context) ServerBackupScheduleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerBackupScheduleMapOutput) +} + +type ServerBackupScheduleOutput struct{ *pulumi.OutputState } + +func (ServerBackupScheduleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerBackupSchedule)(nil)).Elem() +} + +func (o ServerBackupScheduleOutput) ToServerBackupScheduleOutput() ServerBackupScheduleOutput { + return o +} + +func (o ServerBackupScheduleOutput) ToServerBackupScheduleOutputWithContext(ctx context.Context) ServerBackupScheduleOutput { + return o +} + +// Backup schedule details for the backups. +func (o ServerBackupScheduleOutput) BackupProperties() ServerBackupScheduleBackupPropertiesOutput { + return o.ApplyT(func(v *ServerBackupSchedule) ServerBackupScheduleBackupPropertiesOutput { return v.BackupProperties }).(ServerBackupScheduleBackupPropertiesOutput) +} + +// Backup schedule ID. +func (o ServerBackupScheduleOutput) BackupScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.IntOutput { return v.BackupScheduleId }).(pulumi.IntOutput) +} + +// Is the backup schedule enabled or disabled. +func (o ServerBackupScheduleOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput) +} + +// The schedule name. +func (o ServerBackupScheduleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the server is associated. +func (o ServerBackupScheduleOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o ServerBackupScheduleOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// Backup schedule described in `rrule` (recurrence rule) format. +func (o ServerBackupScheduleOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.StringOutput { return v.Rrule }).(pulumi.StringOutput) +} + +// Server ID for the backup schedule. +func (o ServerBackupScheduleOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerBackupSchedule) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +type ServerBackupScheduleArrayOutput struct{ *pulumi.OutputState } + +func (ServerBackupScheduleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerBackupSchedule)(nil)).Elem() +} + +func (o ServerBackupScheduleArrayOutput) ToServerBackupScheduleArrayOutput() ServerBackupScheduleArrayOutput { + return o +} + +func (o ServerBackupScheduleArrayOutput) ToServerBackupScheduleArrayOutputWithContext(ctx context.Context) ServerBackupScheduleArrayOutput { + return o +} + +func (o ServerBackupScheduleArrayOutput) Index(i pulumi.IntInput) ServerBackupScheduleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServerBackupSchedule { + return vs[0].([]*ServerBackupSchedule)[vs[1].(int)] + }).(ServerBackupScheduleOutput) +} + +type ServerBackupScheduleMapOutput struct{ *pulumi.OutputState } + +func (ServerBackupScheduleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerBackupSchedule)(nil)).Elem() +} + +func (o ServerBackupScheduleMapOutput) ToServerBackupScheduleMapOutput() ServerBackupScheduleMapOutput { + return o +} + +func (o ServerBackupScheduleMapOutput) ToServerBackupScheduleMapOutputWithContext(ctx context.Context) ServerBackupScheduleMapOutput { + return o +} + +func (o ServerBackupScheduleMapOutput) MapIndex(k pulumi.StringInput) ServerBackupScheduleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServerBackupSchedule { + return vs[0].(map[string]*ServerBackupSchedule)[vs[1].(string)] + }).(ServerBackupScheduleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerBackupScheduleInput)(nil)).Elem(), &ServerBackupSchedule{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBackupScheduleArrayInput)(nil)).Elem(), ServerBackupScheduleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerBackupScheduleMapInput)(nil)).Elem(), ServerBackupScheduleMap{}) + pulumi.RegisterOutputType(ServerBackupScheduleOutput{}) + pulumi.RegisterOutputType(ServerBackupScheduleArrayOutput{}) + pulumi.RegisterOutputType(ServerBackupScheduleMapOutput{}) +} diff --git a/sdk/go/stackit/serverNetworkInterfaceAttach.go b/sdk/go/stackit/serverNetworkInterfaceAttach.go new file mode 100644 index 0000000..0f995d9 --- /dev/null +++ b/sdk/go/stackit/serverNetworkInterfaceAttach.go @@ -0,0 +1,257 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot. +// +// ## Example Usage +type ServerNetworkInterfaceAttach struct { + pulumi.CustomResourceState + + // The network interface ID. + NetworkInterfaceId pulumi.StringOutput `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface attachment is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The server ID. + ServerId pulumi.StringOutput `pulumi:"serverId"` +} + +// NewServerNetworkInterfaceAttach registers a new resource with the given unique name, arguments, and options. +func NewServerNetworkInterfaceAttach(ctx *pulumi.Context, + name string, args *ServerNetworkInterfaceAttachArgs, opts ...pulumi.ResourceOption) (*ServerNetworkInterfaceAttach, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NetworkInterfaceId == nil { + return nil, errors.New("invalid value for required argument 'NetworkInterfaceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.ServerId == nil { + return nil, errors.New("invalid value for required argument 'ServerId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServerNetworkInterfaceAttach + err := ctx.RegisterResource("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServerNetworkInterfaceAttach gets an existing ServerNetworkInterfaceAttach 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 GetServerNetworkInterfaceAttach(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerNetworkInterfaceAttachState, opts ...pulumi.ResourceOption) (*ServerNetworkInterfaceAttach, error) { + var resource ServerNetworkInterfaceAttach + err := ctx.ReadResource("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServerNetworkInterfaceAttach resources. +type serverNetworkInterfaceAttachState struct { + // The network interface ID. + NetworkInterfaceId *string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface attachment is associated. + ProjectId *string `pulumi:"projectId"` + // The server ID. + ServerId *string `pulumi:"serverId"` +} + +type ServerNetworkInterfaceAttachState struct { + // The network interface ID. + NetworkInterfaceId pulumi.StringPtrInput + // STACKIT project ID to which the network interface attachment is associated. + ProjectId pulumi.StringPtrInput + // The server ID. + ServerId pulumi.StringPtrInput +} + +func (ServerNetworkInterfaceAttachState) ElementType() reflect.Type { + return reflect.TypeOf((*serverNetworkInterfaceAttachState)(nil)).Elem() +} + +type serverNetworkInterfaceAttachArgs struct { + // The network interface ID. + NetworkInterfaceId string `pulumi:"networkInterfaceId"` + // STACKIT project ID to which the network interface attachment is associated. + ProjectId string `pulumi:"projectId"` + // The server ID. + ServerId string `pulumi:"serverId"` +} + +// The set of arguments for constructing a ServerNetworkInterfaceAttach resource. +type ServerNetworkInterfaceAttachArgs struct { + // The network interface ID. + NetworkInterfaceId pulumi.StringInput + // STACKIT project ID to which the network interface attachment is associated. + ProjectId pulumi.StringInput + // The server ID. + ServerId pulumi.StringInput +} + +func (ServerNetworkInterfaceAttachArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverNetworkInterfaceAttachArgs)(nil)).Elem() +} + +type ServerNetworkInterfaceAttachInput interface { + pulumi.Input + + ToServerNetworkInterfaceAttachOutput() ServerNetworkInterfaceAttachOutput + ToServerNetworkInterfaceAttachOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachOutput +} + +func (*ServerNetworkInterfaceAttach) ElementType() reflect.Type { + return reflect.TypeOf((**ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (i *ServerNetworkInterfaceAttach) ToServerNetworkInterfaceAttachOutput() ServerNetworkInterfaceAttachOutput { + return i.ToServerNetworkInterfaceAttachOutputWithContext(context.Background()) +} + +func (i *ServerNetworkInterfaceAttach) ToServerNetworkInterfaceAttachOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerNetworkInterfaceAttachOutput) +} + +// ServerNetworkInterfaceAttachArrayInput is an input type that accepts ServerNetworkInterfaceAttachArray and ServerNetworkInterfaceAttachArrayOutput values. +// You can construct a concrete instance of `ServerNetworkInterfaceAttachArrayInput` via: +// +// ServerNetworkInterfaceAttachArray{ ServerNetworkInterfaceAttachArgs{...} } +type ServerNetworkInterfaceAttachArrayInput interface { + pulumi.Input + + ToServerNetworkInterfaceAttachArrayOutput() ServerNetworkInterfaceAttachArrayOutput + ToServerNetworkInterfaceAttachArrayOutputWithContext(context.Context) ServerNetworkInterfaceAttachArrayOutput +} + +type ServerNetworkInterfaceAttachArray []ServerNetworkInterfaceAttachInput + +func (ServerNetworkInterfaceAttachArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (i ServerNetworkInterfaceAttachArray) ToServerNetworkInterfaceAttachArrayOutput() ServerNetworkInterfaceAttachArrayOutput { + return i.ToServerNetworkInterfaceAttachArrayOutputWithContext(context.Background()) +} + +func (i ServerNetworkInterfaceAttachArray) ToServerNetworkInterfaceAttachArrayOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerNetworkInterfaceAttachArrayOutput) +} + +// ServerNetworkInterfaceAttachMapInput is an input type that accepts ServerNetworkInterfaceAttachMap and ServerNetworkInterfaceAttachMapOutput values. +// You can construct a concrete instance of `ServerNetworkInterfaceAttachMapInput` via: +// +// ServerNetworkInterfaceAttachMap{ "key": ServerNetworkInterfaceAttachArgs{...} } +type ServerNetworkInterfaceAttachMapInput interface { + pulumi.Input + + ToServerNetworkInterfaceAttachMapOutput() ServerNetworkInterfaceAttachMapOutput + ToServerNetworkInterfaceAttachMapOutputWithContext(context.Context) ServerNetworkInterfaceAttachMapOutput +} + +type ServerNetworkInterfaceAttachMap map[string]ServerNetworkInterfaceAttachInput + +func (ServerNetworkInterfaceAttachMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (i ServerNetworkInterfaceAttachMap) ToServerNetworkInterfaceAttachMapOutput() ServerNetworkInterfaceAttachMapOutput { + return i.ToServerNetworkInterfaceAttachMapOutputWithContext(context.Background()) +} + +func (i ServerNetworkInterfaceAttachMap) ToServerNetworkInterfaceAttachMapOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerNetworkInterfaceAttachMapOutput) +} + +type ServerNetworkInterfaceAttachOutput struct{ *pulumi.OutputState } + +func (ServerNetworkInterfaceAttachOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (o ServerNetworkInterfaceAttachOutput) ToServerNetworkInterfaceAttachOutput() ServerNetworkInterfaceAttachOutput { + return o +} + +func (o ServerNetworkInterfaceAttachOutput) ToServerNetworkInterfaceAttachOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachOutput { + return o +} + +// The network interface ID. +func (o ServerNetworkInterfaceAttachOutput) NetworkInterfaceId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerNetworkInterfaceAttach) pulumi.StringOutput { return v.NetworkInterfaceId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the network interface attachment is associated. +func (o ServerNetworkInterfaceAttachOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerNetworkInterfaceAttach) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID. +func (o ServerNetworkInterfaceAttachOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerNetworkInterfaceAttach) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +type ServerNetworkInterfaceAttachArrayOutput struct{ *pulumi.OutputState } + +func (ServerNetworkInterfaceAttachArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (o ServerNetworkInterfaceAttachArrayOutput) ToServerNetworkInterfaceAttachArrayOutput() ServerNetworkInterfaceAttachArrayOutput { + return o +} + +func (o ServerNetworkInterfaceAttachArrayOutput) ToServerNetworkInterfaceAttachArrayOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachArrayOutput { + return o +} + +func (o ServerNetworkInterfaceAttachArrayOutput) Index(i pulumi.IntInput) ServerNetworkInterfaceAttachOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServerNetworkInterfaceAttach { + return vs[0].([]*ServerNetworkInterfaceAttach)[vs[1].(int)] + }).(ServerNetworkInterfaceAttachOutput) +} + +type ServerNetworkInterfaceAttachMapOutput struct{ *pulumi.OutputState } + +func (ServerNetworkInterfaceAttachMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerNetworkInterfaceAttach)(nil)).Elem() +} + +func (o ServerNetworkInterfaceAttachMapOutput) ToServerNetworkInterfaceAttachMapOutput() ServerNetworkInterfaceAttachMapOutput { + return o +} + +func (o ServerNetworkInterfaceAttachMapOutput) ToServerNetworkInterfaceAttachMapOutputWithContext(ctx context.Context) ServerNetworkInterfaceAttachMapOutput { + return o +} + +func (o ServerNetworkInterfaceAttachMapOutput) MapIndex(k pulumi.StringInput) ServerNetworkInterfaceAttachOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServerNetworkInterfaceAttach { + return vs[0].(map[string]*ServerNetworkInterfaceAttach)[vs[1].(string)] + }).(ServerNetworkInterfaceAttachOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerNetworkInterfaceAttachInput)(nil)).Elem(), &ServerNetworkInterfaceAttach{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerNetworkInterfaceAttachArrayInput)(nil)).Elem(), ServerNetworkInterfaceAttachArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerNetworkInterfaceAttachMapInput)(nil)).Elem(), ServerNetworkInterfaceAttachMap{}) + pulumi.RegisterOutputType(ServerNetworkInterfaceAttachOutput{}) + pulumi.RegisterOutputType(ServerNetworkInterfaceAttachArrayOutput{}) + pulumi.RegisterOutputType(ServerNetworkInterfaceAttachMapOutput{}) +} diff --git a/sdk/go/stackit/serverServiceAccountAttach.go b/sdk/go/stackit/serverServiceAccountAttach.go new file mode 100644 index 0000000..8b5cf55 --- /dev/null +++ b/sdk/go/stackit/serverServiceAccountAttach.go @@ -0,0 +1,257 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ServerServiceAccountAttach struct { + pulumi.CustomResourceState + + // STACKIT project ID to which the service account attachment is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The server ID. + ServerId pulumi.StringOutput `pulumi:"serverId"` + // The service account email. + ServiceAccountEmail pulumi.StringOutput `pulumi:"serviceAccountEmail"` +} + +// NewServerServiceAccountAttach registers a new resource with the given unique name, arguments, and options. +func NewServerServiceAccountAttach(ctx *pulumi.Context, + name string, args *ServerServiceAccountAttachArgs, opts ...pulumi.ResourceOption) (*ServerServiceAccountAttach, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.ServerId == nil { + return nil, errors.New("invalid value for required argument 'ServerId'") + } + if args.ServiceAccountEmail == nil { + return nil, errors.New("invalid value for required argument 'ServiceAccountEmail'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServerServiceAccountAttach + err := ctx.RegisterResource("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServerServiceAccountAttach gets an existing ServerServiceAccountAttach 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 GetServerServiceAccountAttach(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerServiceAccountAttachState, opts ...pulumi.ResourceOption) (*ServerServiceAccountAttach, error) { + var resource ServerServiceAccountAttach + err := ctx.ReadResource("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServerServiceAccountAttach resources. +type serverServiceAccountAttachState struct { + // STACKIT project ID to which the service account attachment is associated. + ProjectId *string `pulumi:"projectId"` + // The server ID. + ServerId *string `pulumi:"serverId"` + // The service account email. + ServiceAccountEmail *string `pulumi:"serviceAccountEmail"` +} + +type ServerServiceAccountAttachState struct { + // STACKIT project ID to which the service account attachment is associated. + ProjectId pulumi.StringPtrInput + // The server ID. + ServerId pulumi.StringPtrInput + // The service account email. + ServiceAccountEmail pulumi.StringPtrInput +} + +func (ServerServiceAccountAttachState) ElementType() reflect.Type { + return reflect.TypeOf((*serverServiceAccountAttachState)(nil)).Elem() +} + +type serverServiceAccountAttachArgs struct { + // STACKIT project ID to which the service account attachment is associated. + ProjectId string `pulumi:"projectId"` + // The server ID. + ServerId string `pulumi:"serverId"` + // The service account email. + ServiceAccountEmail string `pulumi:"serviceAccountEmail"` +} + +// The set of arguments for constructing a ServerServiceAccountAttach resource. +type ServerServiceAccountAttachArgs struct { + // STACKIT project ID to which the service account attachment is associated. + ProjectId pulumi.StringInput + // The server ID. + ServerId pulumi.StringInput + // The service account email. + ServiceAccountEmail pulumi.StringInput +} + +func (ServerServiceAccountAttachArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverServiceAccountAttachArgs)(nil)).Elem() +} + +type ServerServiceAccountAttachInput interface { + pulumi.Input + + ToServerServiceAccountAttachOutput() ServerServiceAccountAttachOutput + ToServerServiceAccountAttachOutputWithContext(ctx context.Context) ServerServiceAccountAttachOutput +} + +func (*ServerServiceAccountAttach) ElementType() reflect.Type { + return reflect.TypeOf((**ServerServiceAccountAttach)(nil)).Elem() +} + +func (i *ServerServiceAccountAttach) ToServerServiceAccountAttachOutput() ServerServiceAccountAttachOutput { + return i.ToServerServiceAccountAttachOutputWithContext(context.Background()) +} + +func (i *ServerServiceAccountAttach) ToServerServiceAccountAttachOutputWithContext(ctx context.Context) ServerServiceAccountAttachOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerServiceAccountAttachOutput) +} + +// ServerServiceAccountAttachArrayInput is an input type that accepts ServerServiceAccountAttachArray and ServerServiceAccountAttachArrayOutput values. +// You can construct a concrete instance of `ServerServiceAccountAttachArrayInput` via: +// +// ServerServiceAccountAttachArray{ ServerServiceAccountAttachArgs{...} } +type ServerServiceAccountAttachArrayInput interface { + pulumi.Input + + ToServerServiceAccountAttachArrayOutput() ServerServiceAccountAttachArrayOutput + ToServerServiceAccountAttachArrayOutputWithContext(context.Context) ServerServiceAccountAttachArrayOutput +} + +type ServerServiceAccountAttachArray []ServerServiceAccountAttachInput + +func (ServerServiceAccountAttachArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerServiceAccountAttach)(nil)).Elem() +} + +func (i ServerServiceAccountAttachArray) ToServerServiceAccountAttachArrayOutput() ServerServiceAccountAttachArrayOutput { + return i.ToServerServiceAccountAttachArrayOutputWithContext(context.Background()) +} + +func (i ServerServiceAccountAttachArray) ToServerServiceAccountAttachArrayOutputWithContext(ctx context.Context) ServerServiceAccountAttachArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerServiceAccountAttachArrayOutput) +} + +// ServerServiceAccountAttachMapInput is an input type that accepts ServerServiceAccountAttachMap and ServerServiceAccountAttachMapOutput values. +// You can construct a concrete instance of `ServerServiceAccountAttachMapInput` via: +// +// ServerServiceAccountAttachMap{ "key": ServerServiceAccountAttachArgs{...} } +type ServerServiceAccountAttachMapInput interface { + pulumi.Input + + ToServerServiceAccountAttachMapOutput() ServerServiceAccountAttachMapOutput + ToServerServiceAccountAttachMapOutputWithContext(context.Context) ServerServiceAccountAttachMapOutput +} + +type ServerServiceAccountAttachMap map[string]ServerServiceAccountAttachInput + +func (ServerServiceAccountAttachMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerServiceAccountAttach)(nil)).Elem() +} + +func (i ServerServiceAccountAttachMap) ToServerServiceAccountAttachMapOutput() ServerServiceAccountAttachMapOutput { + return i.ToServerServiceAccountAttachMapOutputWithContext(context.Background()) +} + +func (i ServerServiceAccountAttachMap) ToServerServiceAccountAttachMapOutputWithContext(ctx context.Context) ServerServiceAccountAttachMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerServiceAccountAttachMapOutput) +} + +type ServerServiceAccountAttachOutput struct{ *pulumi.OutputState } + +func (ServerServiceAccountAttachOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerServiceAccountAttach)(nil)).Elem() +} + +func (o ServerServiceAccountAttachOutput) ToServerServiceAccountAttachOutput() ServerServiceAccountAttachOutput { + return o +} + +func (o ServerServiceAccountAttachOutput) ToServerServiceAccountAttachOutputWithContext(ctx context.Context) ServerServiceAccountAttachOutput { + return o +} + +// STACKIT project ID to which the service account attachment is associated. +func (o ServerServiceAccountAttachOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerServiceAccountAttach) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID. +func (o ServerServiceAccountAttachOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerServiceAccountAttach) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +// The service account email. +func (o ServerServiceAccountAttachOutput) ServiceAccountEmail() pulumi.StringOutput { + return o.ApplyT(func(v *ServerServiceAccountAttach) pulumi.StringOutput { return v.ServiceAccountEmail }).(pulumi.StringOutput) +} + +type ServerServiceAccountAttachArrayOutput struct{ *pulumi.OutputState } + +func (ServerServiceAccountAttachArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerServiceAccountAttach)(nil)).Elem() +} + +func (o ServerServiceAccountAttachArrayOutput) ToServerServiceAccountAttachArrayOutput() ServerServiceAccountAttachArrayOutput { + return o +} + +func (o ServerServiceAccountAttachArrayOutput) ToServerServiceAccountAttachArrayOutputWithContext(ctx context.Context) ServerServiceAccountAttachArrayOutput { + return o +} + +func (o ServerServiceAccountAttachArrayOutput) Index(i pulumi.IntInput) ServerServiceAccountAttachOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServerServiceAccountAttach { + return vs[0].([]*ServerServiceAccountAttach)[vs[1].(int)] + }).(ServerServiceAccountAttachOutput) +} + +type ServerServiceAccountAttachMapOutput struct{ *pulumi.OutputState } + +func (ServerServiceAccountAttachMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerServiceAccountAttach)(nil)).Elem() +} + +func (o ServerServiceAccountAttachMapOutput) ToServerServiceAccountAttachMapOutput() ServerServiceAccountAttachMapOutput { + return o +} + +func (o ServerServiceAccountAttachMapOutput) ToServerServiceAccountAttachMapOutputWithContext(ctx context.Context) ServerServiceAccountAttachMapOutput { + return o +} + +func (o ServerServiceAccountAttachMapOutput) MapIndex(k pulumi.StringInput) ServerServiceAccountAttachOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServerServiceAccountAttach { + return vs[0].(map[string]*ServerServiceAccountAttach)[vs[1].(string)] + }).(ServerServiceAccountAttachOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerServiceAccountAttachInput)(nil)).Elem(), &ServerServiceAccountAttach{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerServiceAccountAttachArrayInput)(nil)).Elem(), ServerServiceAccountAttachArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerServiceAccountAttachMapInput)(nil)).Elem(), ServerServiceAccountAttachMap{}) + pulumi.RegisterOutputType(ServerServiceAccountAttachOutput{}) + pulumi.RegisterOutputType(ServerServiceAccountAttachArrayOutput{}) + pulumi.RegisterOutputType(ServerServiceAccountAttachMapOutput{}) +} diff --git a/sdk/go/stackit/serverUpdateSchedule.go b/sdk/go/stackit/serverUpdateSchedule.go new file mode 100644 index 0000000..b3f628a --- /dev/null +++ b/sdk/go/stackit/serverUpdateSchedule.go @@ -0,0 +1,336 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Server update schedule resource schema. Must have a `region` specified in the provider configuration. +// +// > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. +// +// ## Example Usage +type ServerUpdateSchedule struct { + pulumi.CustomResourceState + + // Is the update schedule enabled or disabled. + Enabled pulumi.BoolOutput `pulumi:"enabled"` + // Maintenance window [1..24]. + MaintenanceWindow pulumi.IntOutput `pulumi:"maintenanceWindow"` + // The schedule name. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringOutput `pulumi:"rrule"` + // Server ID for the update schedule. + ServerId pulumi.StringOutput `pulumi:"serverId"` + // Update schedule ID. + UpdateScheduleId pulumi.IntOutput `pulumi:"updateScheduleId"` +} + +// NewServerUpdateSchedule registers a new resource with the given unique name, arguments, and options. +func NewServerUpdateSchedule(ctx *pulumi.Context, + name string, args *ServerUpdateScheduleArgs, opts ...pulumi.ResourceOption) (*ServerUpdateSchedule, 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.MaintenanceWindow == nil { + return nil, errors.New("invalid value for required argument 'MaintenanceWindow'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Rrule == nil { + return nil, errors.New("invalid value for required argument 'Rrule'") + } + if args.ServerId == nil { + return nil, errors.New("invalid value for required argument 'ServerId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServerUpdateSchedule + err := ctx.RegisterResource("stackit:index/serverUpdateSchedule:ServerUpdateSchedule", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServerUpdateSchedule gets an existing ServerUpdateSchedule 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 GetServerUpdateSchedule(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerUpdateScheduleState, opts ...pulumi.ResourceOption) (*ServerUpdateSchedule, error) { + var resource ServerUpdateSchedule + err := ctx.ReadResource("stackit:index/serverUpdateSchedule:ServerUpdateSchedule", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServerUpdateSchedule resources. +type serverUpdateScheduleState struct { + // Is the update schedule enabled or disabled. + Enabled *bool `pulumi:"enabled"` + // Maintenance window [1..24]. + MaintenanceWindow *int `pulumi:"maintenanceWindow"` + // The schedule name. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule *string `pulumi:"rrule"` + // Server ID for the update schedule. + ServerId *string `pulumi:"serverId"` + // Update schedule ID. + UpdateScheduleId *int `pulumi:"updateScheduleId"` +} + +type ServerUpdateScheduleState struct { + // Is the update schedule enabled or disabled. + Enabled pulumi.BoolPtrInput + // Maintenance window [1..24]. + MaintenanceWindow pulumi.IntPtrInput + // The schedule name. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Update schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringPtrInput + // Server ID for the update schedule. + ServerId pulumi.StringPtrInput + // Update schedule ID. + UpdateScheduleId pulumi.IntPtrInput +} + +func (ServerUpdateScheduleState) ElementType() reflect.Type { + return reflect.TypeOf((*serverUpdateScheduleState)(nil)).Elem() +} + +type serverUpdateScheduleArgs struct { + // Is the update schedule enabled or disabled. + Enabled bool `pulumi:"enabled"` + // Maintenance window [1..24]. + MaintenanceWindow int `pulumi:"maintenanceWindow"` + // The schedule name. + Name *string `pulumi:"name"` + // STACKIT Project ID to which the server is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + // Update schedule described in `rrule` (recurrence rule) format. + Rrule string `pulumi:"rrule"` + // Server ID for the update schedule. + ServerId string `pulumi:"serverId"` +} + +// The set of arguments for constructing a ServerUpdateSchedule resource. +type ServerUpdateScheduleArgs struct { + // Is the update schedule enabled or disabled. + Enabled pulumi.BoolInput + // Maintenance window [1..24]. + MaintenanceWindow pulumi.IntInput + // The schedule name. + Name pulumi.StringPtrInput + // STACKIT Project ID to which the server is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + // Update schedule described in `rrule` (recurrence rule) format. + Rrule pulumi.StringInput + // Server ID for the update schedule. + ServerId pulumi.StringInput +} + +func (ServerUpdateScheduleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverUpdateScheduleArgs)(nil)).Elem() +} + +type ServerUpdateScheduleInput interface { + pulumi.Input + + ToServerUpdateScheduleOutput() ServerUpdateScheduleOutput + ToServerUpdateScheduleOutputWithContext(ctx context.Context) ServerUpdateScheduleOutput +} + +func (*ServerUpdateSchedule) ElementType() reflect.Type { + return reflect.TypeOf((**ServerUpdateSchedule)(nil)).Elem() +} + +func (i *ServerUpdateSchedule) ToServerUpdateScheduleOutput() ServerUpdateScheduleOutput { + return i.ToServerUpdateScheduleOutputWithContext(context.Background()) +} + +func (i *ServerUpdateSchedule) ToServerUpdateScheduleOutputWithContext(ctx context.Context) ServerUpdateScheduleOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerUpdateScheduleOutput) +} + +// ServerUpdateScheduleArrayInput is an input type that accepts ServerUpdateScheduleArray and ServerUpdateScheduleArrayOutput values. +// You can construct a concrete instance of `ServerUpdateScheduleArrayInput` via: +// +// ServerUpdateScheduleArray{ ServerUpdateScheduleArgs{...} } +type ServerUpdateScheduleArrayInput interface { + pulumi.Input + + ToServerUpdateScheduleArrayOutput() ServerUpdateScheduleArrayOutput + ToServerUpdateScheduleArrayOutputWithContext(context.Context) ServerUpdateScheduleArrayOutput +} + +type ServerUpdateScheduleArray []ServerUpdateScheduleInput + +func (ServerUpdateScheduleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerUpdateSchedule)(nil)).Elem() +} + +func (i ServerUpdateScheduleArray) ToServerUpdateScheduleArrayOutput() ServerUpdateScheduleArrayOutput { + return i.ToServerUpdateScheduleArrayOutputWithContext(context.Background()) +} + +func (i ServerUpdateScheduleArray) ToServerUpdateScheduleArrayOutputWithContext(ctx context.Context) ServerUpdateScheduleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerUpdateScheduleArrayOutput) +} + +// ServerUpdateScheduleMapInput is an input type that accepts ServerUpdateScheduleMap and ServerUpdateScheduleMapOutput values. +// You can construct a concrete instance of `ServerUpdateScheduleMapInput` via: +// +// ServerUpdateScheduleMap{ "key": ServerUpdateScheduleArgs{...} } +type ServerUpdateScheduleMapInput interface { + pulumi.Input + + ToServerUpdateScheduleMapOutput() ServerUpdateScheduleMapOutput + ToServerUpdateScheduleMapOutputWithContext(context.Context) ServerUpdateScheduleMapOutput +} + +type ServerUpdateScheduleMap map[string]ServerUpdateScheduleInput + +func (ServerUpdateScheduleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerUpdateSchedule)(nil)).Elem() +} + +func (i ServerUpdateScheduleMap) ToServerUpdateScheduleMapOutput() ServerUpdateScheduleMapOutput { + return i.ToServerUpdateScheduleMapOutputWithContext(context.Background()) +} + +func (i ServerUpdateScheduleMap) ToServerUpdateScheduleMapOutputWithContext(ctx context.Context) ServerUpdateScheduleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerUpdateScheduleMapOutput) +} + +type ServerUpdateScheduleOutput struct{ *pulumi.OutputState } + +func (ServerUpdateScheduleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerUpdateSchedule)(nil)).Elem() +} + +func (o ServerUpdateScheduleOutput) ToServerUpdateScheduleOutput() ServerUpdateScheduleOutput { + return o +} + +func (o ServerUpdateScheduleOutput) ToServerUpdateScheduleOutputWithContext(ctx context.Context) ServerUpdateScheduleOutput { + return o +} + +// Is the update schedule enabled or disabled. +func (o ServerUpdateScheduleOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput) +} + +// Maintenance window [1..24]. +func (o ServerUpdateScheduleOutput) MaintenanceWindow() pulumi.IntOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.IntOutput { return v.MaintenanceWindow }).(pulumi.IntOutput) +} + +// The schedule name. +func (o ServerUpdateScheduleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT Project ID to which the server is associated. +func (o ServerUpdateScheduleOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o ServerUpdateScheduleOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// Update schedule described in `rrule` (recurrence rule) format. +func (o ServerUpdateScheduleOutput) Rrule() pulumi.StringOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.StringOutput { return v.Rrule }).(pulumi.StringOutput) +} + +// Server ID for the update schedule. +func (o ServerUpdateScheduleOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +// Update schedule ID. +func (o ServerUpdateScheduleOutput) UpdateScheduleId() pulumi.IntOutput { + return o.ApplyT(func(v *ServerUpdateSchedule) pulumi.IntOutput { return v.UpdateScheduleId }).(pulumi.IntOutput) +} + +type ServerUpdateScheduleArrayOutput struct{ *pulumi.OutputState } + +func (ServerUpdateScheduleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerUpdateSchedule)(nil)).Elem() +} + +func (o ServerUpdateScheduleArrayOutput) ToServerUpdateScheduleArrayOutput() ServerUpdateScheduleArrayOutput { + return o +} + +func (o ServerUpdateScheduleArrayOutput) ToServerUpdateScheduleArrayOutputWithContext(ctx context.Context) ServerUpdateScheduleArrayOutput { + return o +} + +func (o ServerUpdateScheduleArrayOutput) Index(i pulumi.IntInput) ServerUpdateScheduleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServerUpdateSchedule { + return vs[0].([]*ServerUpdateSchedule)[vs[1].(int)] + }).(ServerUpdateScheduleOutput) +} + +type ServerUpdateScheduleMapOutput struct{ *pulumi.OutputState } + +func (ServerUpdateScheduleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerUpdateSchedule)(nil)).Elem() +} + +func (o ServerUpdateScheduleMapOutput) ToServerUpdateScheduleMapOutput() ServerUpdateScheduleMapOutput { + return o +} + +func (o ServerUpdateScheduleMapOutput) ToServerUpdateScheduleMapOutputWithContext(ctx context.Context) ServerUpdateScheduleMapOutput { + return o +} + +func (o ServerUpdateScheduleMapOutput) MapIndex(k pulumi.StringInput) ServerUpdateScheduleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServerUpdateSchedule { + return vs[0].(map[string]*ServerUpdateSchedule)[vs[1].(string)] + }).(ServerUpdateScheduleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerUpdateScheduleInput)(nil)).Elem(), &ServerUpdateSchedule{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerUpdateScheduleArrayInput)(nil)).Elem(), ServerUpdateScheduleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerUpdateScheduleMapInput)(nil)).Elem(), ServerUpdateScheduleMap{}) + pulumi.RegisterOutputType(ServerUpdateScheduleOutput{}) + pulumi.RegisterOutputType(ServerUpdateScheduleArrayOutput{}) + pulumi.RegisterOutputType(ServerUpdateScheduleMapOutput{}) +} diff --git a/sdk/go/stackit/serverVolumeAttach.go b/sdk/go/stackit/serverVolumeAttach.go new file mode 100644 index 0000000..e63566e --- /dev/null +++ b/sdk/go/stackit/serverVolumeAttach.go @@ -0,0 +1,257 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type ServerVolumeAttach struct { + pulumi.CustomResourceState + + // STACKIT project ID to which the volume attachment is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The server ID. + ServerId pulumi.StringOutput `pulumi:"serverId"` + // The volume ID. + VolumeId pulumi.StringOutput `pulumi:"volumeId"` +} + +// NewServerVolumeAttach registers a new resource with the given unique name, arguments, and options. +func NewServerVolumeAttach(ctx *pulumi.Context, + name string, args *ServerVolumeAttachArgs, opts ...pulumi.ResourceOption) (*ServerVolumeAttach, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.ServerId == nil { + return nil, errors.New("invalid value for required argument 'ServerId'") + } + if args.VolumeId == nil { + return nil, errors.New("invalid value for required argument 'VolumeId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServerVolumeAttach + err := ctx.RegisterResource("stackit:index/serverVolumeAttach:ServerVolumeAttach", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServerVolumeAttach gets an existing ServerVolumeAttach 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 GetServerVolumeAttach(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServerVolumeAttachState, opts ...pulumi.ResourceOption) (*ServerVolumeAttach, error) { + var resource ServerVolumeAttach + err := ctx.ReadResource("stackit:index/serverVolumeAttach:ServerVolumeAttach", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServerVolumeAttach resources. +type serverVolumeAttachState struct { + // STACKIT project ID to which the volume attachment is associated. + ProjectId *string `pulumi:"projectId"` + // The server ID. + ServerId *string `pulumi:"serverId"` + // The volume ID. + VolumeId *string `pulumi:"volumeId"` +} + +type ServerVolumeAttachState struct { + // STACKIT project ID to which the volume attachment is associated. + ProjectId pulumi.StringPtrInput + // The server ID. + ServerId pulumi.StringPtrInput + // The volume ID. + VolumeId pulumi.StringPtrInput +} + +func (ServerVolumeAttachState) ElementType() reflect.Type { + return reflect.TypeOf((*serverVolumeAttachState)(nil)).Elem() +} + +type serverVolumeAttachArgs struct { + // STACKIT project ID to which the volume attachment is associated. + ProjectId string `pulumi:"projectId"` + // The server ID. + ServerId string `pulumi:"serverId"` + // The volume ID. + VolumeId string `pulumi:"volumeId"` +} + +// The set of arguments for constructing a ServerVolumeAttach resource. +type ServerVolumeAttachArgs struct { + // STACKIT project ID to which the volume attachment is associated. + ProjectId pulumi.StringInput + // The server ID. + ServerId pulumi.StringInput + // The volume ID. + VolumeId pulumi.StringInput +} + +func (ServerVolumeAttachArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serverVolumeAttachArgs)(nil)).Elem() +} + +type ServerVolumeAttachInput interface { + pulumi.Input + + ToServerVolumeAttachOutput() ServerVolumeAttachOutput + ToServerVolumeAttachOutputWithContext(ctx context.Context) ServerVolumeAttachOutput +} + +func (*ServerVolumeAttach) ElementType() reflect.Type { + return reflect.TypeOf((**ServerVolumeAttach)(nil)).Elem() +} + +func (i *ServerVolumeAttach) ToServerVolumeAttachOutput() ServerVolumeAttachOutput { + return i.ToServerVolumeAttachOutputWithContext(context.Background()) +} + +func (i *ServerVolumeAttach) ToServerVolumeAttachOutputWithContext(ctx context.Context) ServerVolumeAttachOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerVolumeAttachOutput) +} + +// ServerVolumeAttachArrayInput is an input type that accepts ServerVolumeAttachArray and ServerVolumeAttachArrayOutput values. +// You can construct a concrete instance of `ServerVolumeAttachArrayInput` via: +// +// ServerVolumeAttachArray{ ServerVolumeAttachArgs{...} } +type ServerVolumeAttachArrayInput interface { + pulumi.Input + + ToServerVolumeAttachArrayOutput() ServerVolumeAttachArrayOutput + ToServerVolumeAttachArrayOutputWithContext(context.Context) ServerVolumeAttachArrayOutput +} + +type ServerVolumeAttachArray []ServerVolumeAttachInput + +func (ServerVolumeAttachArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerVolumeAttach)(nil)).Elem() +} + +func (i ServerVolumeAttachArray) ToServerVolumeAttachArrayOutput() ServerVolumeAttachArrayOutput { + return i.ToServerVolumeAttachArrayOutputWithContext(context.Background()) +} + +func (i ServerVolumeAttachArray) ToServerVolumeAttachArrayOutputWithContext(ctx context.Context) ServerVolumeAttachArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerVolumeAttachArrayOutput) +} + +// ServerVolumeAttachMapInput is an input type that accepts ServerVolumeAttachMap and ServerVolumeAttachMapOutput values. +// You can construct a concrete instance of `ServerVolumeAttachMapInput` via: +// +// ServerVolumeAttachMap{ "key": ServerVolumeAttachArgs{...} } +type ServerVolumeAttachMapInput interface { + pulumi.Input + + ToServerVolumeAttachMapOutput() ServerVolumeAttachMapOutput + ToServerVolumeAttachMapOutputWithContext(context.Context) ServerVolumeAttachMapOutput +} + +type ServerVolumeAttachMap map[string]ServerVolumeAttachInput + +func (ServerVolumeAttachMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerVolumeAttach)(nil)).Elem() +} + +func (i ServerVolumeAttachMap) ToServerVolumeAttachMapOutput() ServerVolumeAttachMapOutput { + return i.ToServerVolumeAttachMapOutputWithContext(context.Background()) +} + +func (i ServerVolumeAttachMap) ToServerVolumeAttachMapOutputWithContext(ctx context.Context) ServerVolumeAttachMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServerVolumeAttachMapOutput) +} + +type ServerVolumeAttachOutput struct{ *pulumi.OutputState } + +func (ServerVolumeAttachOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServerVolumeAttach)(nil)).Elem() +} + +func (o ServerVolumeAttachOutput) ToServerVolumeAttachOutput() ServerVolumeAttachOutput { + return o +} + +func (o ServerVolumeAttachOutput) ToServerVolumeAttachOutputWithContext(ctx context.Context) ServerVolumeAttachOutput { + return o +} + +// STACKIT project ID to which the volume attachment is associated. +func (o ServerVolumeAttachOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerVolumeAttach) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID. +func (o ServerVolumeAttachOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerVolumeAttach) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +// The volume ID. +func (o ServerVolumeAttachOutput) VolumeId() pulumi.StringOutput { + return o.ApplyT(func(v *ServerVolumeAttach) pulumi.StringOutput { return v.VolumeId }).(pulumi.StringOutput) +} + +type ServerVolumeAttachArrayOutput struct{ *pulumi.OutputState } + +func (ServerVolumeAttachArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServerVolumeAttach)(nil)).Elem() +} + +func (o ServerVolumeAttachArrayOutput) ToServerVolumeAttachArrayOutput() ServerVolumeAttachArrayOutput { + return o +} + +func (o ServerVolumeAttachArrayOutput) ToServerVolumeAttachArrayOutputWithContext(ctx context.Context) ServerVolumeAttachArrayOutput { + return o +} + +func (o ServerVolumeAttachArrayOutput) Index(i pulumi.IntInput) ServerVolumeAttachOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServerVolumeAttach { + return vs[0].([]*ServerVolumeAttach)[vs[1].(int)] + }).(ServerVolumeAttachOutput) +} + +type ServerVolumeAttachMapOutput struct{ *pulumi.OutputState } + +func (ServerVolumeAttachMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServerVolumeAttach)(nil)).Elem() +} + +func (o ServerVolumeAttachMapOutput) ToServerVolumeAttachMapOutput() ServerVolumeAttachMapOutput { + return o +} + +func (o ServerVolumeAttachMapOutput) ToServerVolumeAttachMapOutputWithContext(ctx context.Context) ServerVolumeAttachMapOutput { + return o +} + +func (o ServerVolumeAttachMapOutput) MapIndex(k pulumi.StringInput) ServerVolumeAttachOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServerVolumeAttach { + return vs[0].(map[string]*ServerVolumeAttach)[vs[1].(string)] + }).(ServerVolumeAttachOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServerVolumeAttachInput)(nil)).Elem(), &ServerVolumeAttach{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerVolumeAttachArrayInput)(nil)).Elem(), ServerVolumeAttachArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServerVolumeAttachMapInput)(nil)).Elem(), ServerVolumeAttachMap{}) + pulumi.RegisterOutputType(ServerVolumeAttachOutput{}) + pulumi.RegisterOutputType(ServerVolumeAttachArrayOutput{}) + pulumi.RegisterOutputType(ServerVolumeAttachMapOutput{}) +} diff --git a/sdk/go/stackit/serviceAccount.go b/sdk/go/stackit/serviceAccount.go new file mode 100644 index 0000000..f514827 --- /dev/null +++ b/sdk/go/stackit/serviceAccount.go @@ -0,0 +1,247 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Service account resource schema. +// +// ## Example Usage +type ServiceAccount struct { + pulumi.CustomResourceState + + // Email of the service account. + Email pulumi.StringOutput `pulumi:"email"` + // Name of the service account. + Name pulumi.StringOutput `pulumi:"name"` + // STACKIT project ID to which the service account is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` +} + +// NewServiceAccount registers a new resource with the given unique name, arguments, and options. +func NewServiceAccount(ctx *pulumi.Context, + name string, args *ServiceAccountArgs, opts ...pulumi.ResourceOption) (*ServiceAccount, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServiceAccount + err := ctx.RegisterResource("stackit:index/serviceAccount:ServiceAccount", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServiceAccount gets an existing ServiceAccount 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 GetServiceAccount(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServiceAccountState, opts ...pulumi.ResourceOption) (*ServiceAccount, error) { + var resource ServiceAccount + err := ctx.ReadResource("stackit:index/serviceAccount:ServiceAccount", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServiceAccount resources. +type serviceAccountState struct { + // Email of the service account. + Email *string `pulumi:"email"` + // Name of the service account. + Name *string `pulumi:"name"` + // STACKIT project ID to which the service account is associated. + ProjectId *string `pulumi:"projectId"` +} + +type ServiceAccountState struct { + // Email of the service account. + Email pulumi.StringPtrInput + // Name of the service account. + Name pulumi.StringPtrInput + // STACKIT project ID to which the service account is associated. + ProjectId pulumi.StringPtrInput +} + +func (ServiceAccountState) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountState)(nil)).Elem() +} + +type serviceAccountArgs struct { + // Name of the service account. + Name *string `pulumi:"name"` + // STACKIT project ID to which the service account is associated. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a ServiceAccount resource. +type ServiceAccountArgs struct { + // Name of the service account. + Name pulumi.StringPtrInput + // STACKIT project ID to which the service account is associated. + ProjectId pulumi.StringInput +} + +func (ServiceAccountArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountArgs)(nil)).Elem() +} + +type ServiceAccountInput interface { + pulumi.Input + + ToServiceAccountOutput() ServiceAccountOutput + ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput +} + +func (*ServiceAccount) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccount)(nil)).Elem() +} + +func (i *ServiceAccount) ToServiceAccountOutput() ServiceAccountOutput { + return i.ToServiceAccountOutputWithContext(context.Background()) +} + +func (i *ServiceAccount) ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountOutput) +} + +// ServiceAccountArrayInput is an input type that accepts ServiceAccountArray and ServiceAccountArrayOutput values. +// You can construct a concrete instance of `ServiceAccountArrayInput` via: +// +// ServiceAccountArray{ ServiceAccountArgs{...} } +type ServiceAccountArrayInput interface { + pulumi.Input + + ToServiceAccountArrayOutput() ServiceAccountArrayOutput + ToServiceAccountArrayOutputWithContext(context.Context) ServiceAccountArrayOutput +} + +type ServiceAccountArray []ServiceAccountInput + +func (ServiceAccountArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccount)(nil)).Elem() +} + +func (i ServiceAccountArray) ToServiceAccountArrayOutput() ServiceAccountArrayOutput { + return i.ToServiceAccountArrayOutputWithContext(context.Background()) +} + +func (i ServiceAccountArray) ToServiceAccountArrayOutputWithContext(ctx context.Context) ServiceAccountArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountArrayOutput) +} + +// ServiceAccountMapInput is an input type that accepts ServiceAccountMap and ServiceAccountMapOutput values. +// You can construct a concrete instance of `ServiceAccountMapInput` via: +// +// ServiceAccountMap{ "key": ServiceAccountArgs{...} } +type ServiceAccountMapInput interface { + pulumi.Input + + ToServiceAccountMapOutput() ServiceAccountMapOutput + ToServiceAccountMapOutputWithContext(context.Context) ServiceAccountMapOutput +} + +type ServiceAccountMap map[string]ServiceAccountInput + +func (ServiceAccountMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccount)(nil)).Elem() +} + +func (i ServiceAccountMap) ToServiceAccountMapOutput() ServiceAccountMapOutput { + return i.ToServiceAccountMapOutputWithContext(context.Background()) +} + +func (i ServiceAccountMap) ToServiceAccountMapOutputWithContext(ctx context.Context) ServiceAccountMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountMapOutput) +} + +type ServiceAccountOutput struct{ *pulumi.OutputState } + +func (ServiceAccountOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccount)(nil)).Elem() +} + +func (o ServiceAccountOutput) ToServiceAccountOutput() ServiceAccountOutput { + return o +} + +func (o ServiceAccountOutput) ToServiceAccountOutputWithContext(ctx context.Context) ServiceAccountOutput { + return o +} + +// Email of the service account. +func (o ServiceAccountOutput) Email() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccount) pulumi.StringOutput { return v.Email }).(pulumi.StringOutput) +} + +// Name of the service account. +func (o ServiceAccountOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccount) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the service account is associated. +func (o ServiceAccountOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccount) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +type ServiceAccountArrayOutput struct{ *pulumi.OutputState } + +func (ServiceAccountArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccount)(nil)).Elem() +} + +func (o ServiceAccountArrayOutput) ToServiceAccountArrayOutput() ServiceAccountArrayOutput { + return o +} + +func (o ServiceAccountArrayOutput) ToServiceAccountArrayOutputWithContext(ctx context.Context) ServiceAccountArrayOutput { + return o +} + +func (o ServiceAccountArrayOutput) Index(i pulumi.IntInput) ServiceAccountOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccount { + return vs[0].([]*ServiceAccount)[vs[1].(int)] + }).(ServiceAccountOutput) +} + +type ServiceAccountMapOutput struct{ *pulumi.OutputState } + +func (ServiceAccountMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccount)(nil)).Elem() +} + +func (o ServiceAccountMapOutput) ToServiceAccountMapOutput() ServiceAccountMapOutput { + return o +} + +func (o ServiceAccountMapOutput) ToServiceAccountMapOutputWithContext(ctx context.Context) ServiceAccountMapOutput { + return o +} + +func (o ServiceAccountMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccount { + return vs[0].(map[string]*ServiceAccount)[vs[1].(string)] + }).(ServiceAccountOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountInput)(nil)).Elem(), &ServiceAccount{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountArrayInput)(nil)).Elem(), ServiceAccountArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountMapInput)(nil)).Elem(), ServiceAccountMap{}) + pulumi.RegisterOutputType(ServiceAccountOutput{}) + pulumi.RegisterOutputType(ServiceAccountArrayOutput{}) + pulumi.RegisterOutputType(ServiceAccountMapOutput{}) +} diff --git a/sdk/go/stackit/serviceAccountAccessToken.go b/sdk/go/stackit/serviceAccountAccessToken.go new file mode 100644 index 0000000..ec96b17 --- /dev/null +++ b/sdk/go/stackit/serviceAccountAccessToken.go @@ -0,0 +1,329 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Service account access token schema. +// ## Example Usage +// +// ### Automatically rotate access tokens +type ServiceAccountAccessToken struct { + pulumi.CustomResourceState + + // Identifier for the access token linked to the service account. + AccessTokenId pulumi.StringOutput `pulumi:"accessTokenId"` + // Indicate whether the token is currently active or inactive + Active pulumi.BoolOutput `pulumi:"active"` + // Timestamp indicating when the access token was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // STACKIT project ID associated with the service account token. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapOutput `pulumi:"rotateWhenChanged"` + // Email address linked to the service account. + ServiceAccountEmail pulumi.StringOutput `pulumi:"serviceAccountEmail"` + // JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + Token pulumi.StringOutput `pulumi:"token"` + // Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + TtlDays pulumi.IntOutput `pulumi:"ttlDays"` + // Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + ValidUntil pulumi.StringOutput `pulumi:"validUntil"` +} + +// NewServiceAccountAccessToken registers a new resource with the given unique name, arguments, and options. +func NewServiceAccountAccessToken(ctx *pulumi.Context, + name string, args *ServiceAccountAccessTokenArgs, opts ...pulumi.ResourceOption) (*ServiceAccountAccessToken, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.ServiceAccountEmail == nil { + return nil, errors.New("invalid value for required argument 'ServiceAccountEmail'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "token", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServiceAccountAccessToken + err := ctx.RegisterResource("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServiceAccountAccessToken gets an existing ServiceAccountAccessToken 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 GetServiceAccountAccessToken(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServiceAccountAccessTokenState, opts ...pulumi.ResourceOption) (*ServiceAccountAccessToken, error) { + var resource ServiceAccountAccessToken + err := ctx.ReadResource("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServiceAccountAccessToken resources. +type serviceAccountAccessTokenState struct { + // Identifier for the access token linked to the service account. + AccessTokenId *string `pulumi:"accessTokenId"` + // Indicate whether the token is currently active or inactive + Active *bool `pulumi:"active"` + // Timestamp indicating when the access token was created. + CreatedAt *string `pulumi:"createdAt"` + // STACKIT project ID associated with the service account token. + ProjectId *string `pulumi:"projectId"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // Email address linked to the service account. + ServiceAccountEmail *string `pulumi:"serviceAccountEmail"` + // JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + Token *string `pulumi:"token"` + // Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + TtlDays *int `pulumi:"ttlDays"` + // Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + ValidUntil *string `pulumi:"validUntil"` +} + +type ServiceAccountAccessTokenState struct { + // Identifier for the access token linked to the service account. + AccessTokenId pulumi.StringPtrInput + // Indicate whether the token is currently active or inactive + Active pulumi.BoolPtrInput + // Timestamp indicating when the access token was created. + CreatedAt pulumi.StringPtrInput + // STACKIT project ID associated with the service account token. + ProjectId pulumi.StringPtrInput + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapInput + // Email address linked to the service account. + ServiceAccountEmail pulumi.StringPtrInput + // JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + Token pulumi.StringPtrInput + // Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + TtlDays pulumi.IntPtrInput + // Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + ValidUntil pulumi.StringPtrInput +} + +func (ServiceAccountAccessTokenState) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountAccessTokenState)(nil)).Elem() +} + +type serviceAccountAccessTokenArgs struct { + // STACKIT project ID associated with the service account token. + ProjectId string `pulumi:"projectId"` + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // Email address linked to the service account. + ServiceAccountEmail string `pulumi:"serviceAccountEmail"` + // Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + TtlDays *int `pulumi:"ttlDays"` +} + +// The set of arguments for constructing a ServiceAccountAccessToken resource. +type ServiceAccountAccessTokenArgs struct { + // STACKIT project ID associated with the service account token. + ProjectId pulumi.StringInput + // A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + RotateWhenChanged pulumi.StringMapInput + // Email address linked to the service account. + ServiceAccountEmail pulumi.StringInput + // Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + TtlDays pulumi.IntPtrInput +} + +func (ServiceAccountAccessTokenArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountAccessTokenArgs)(nil)).Elem() +} + +type ServiceAccountAccessTokenInput interface { + pulumi.Input + + ToServiceAccountAccessTokenOutput() ServiceAccountAccessTokenOutput + ToServiceAccountAccessTokenOutputWithContext(ctx context.Context) ServiceAccountAccessTokenOutput +} + +func (*ServiceAccountAccessToken) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccountAccessToken)(nil)).Elem() +} + +func (i *ServiceAccountAccessToken) ToServiceAccountAccessTokenOutput() ServiceAccountAccessTokenOutput { + return i.ToServiceAccountAccessTokenOutputWithContext(context.Background()) +} + +func (i *ServiceAccountAccessToken) ToServiceAccountAccessTokenOutputWithContext(ctx context.Context) ServiceAccountAccessTokenOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountAccessTokenOutput) +} + +// ServiceAccountAccessTokenArrayInput is an input type that accepts ServiceAccountAccessTokenArray and ServiceAccountAccessTokenArrayOutput values. +// You can construct a concrete instance of `ServiceAccountAccessTokenArrayInput` via: +// +// ServiceAccountAccessTokenArray{ ServiceAccountAccessTokenArgs{...} } +type ServiceAccountAccessTokenArrayInput interface { + pulumi.Input + + ToServiceAccountAccessTokenArrayOutput() ServiceAccountAccessTokenArrayOutput + ToServiceAccountAccessTokenArrayOutputWithContext(context.Context) ServiceAccountAccessTokenArrayOutput +} + +type ServiceAccountAccessTokenArray []ServiceAccountAccessTokenInput + +func (ServiceAccountAccessTokenArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccountAccessToken)(nil)).Elem() +} + +func (i ServiceAccountAccessTokenArray) ToServiceAccountAccessTokenArrayOutput() ServiceAccountAccessTokenArrayOutput { + return i.ToServiceAccountAccessTokenArrayOutputWithContext(context.Background()) +} + +func (i ServiceAccountAccessTokenArray) ToServiceAccountAccessTokenArrayOutputWithContext(ctx context.Context) ServiceAccountAccessTokenArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountAccessTokenArrayOutput) +} + +// ServiceAccountAccessTokenMapInput is an input type that accepts ServiceAccountAccessTokenMap and ServiceAccountAccessTokenMapOutput values. +// You can construct a concrete instance of `ServiceAccountAccessTokenMapInput` via: +// +// ServiceAccountAccessTokenMap{ "key": ServiceAccountAccessTokenArgs{...} } +type ServiceAccountAccessTokenMapInput interface { + pulumi.Input + + ToServiceAccountAccessTokenMapOutput() ServiceAccountAccessTokenMapOutput + ToServiceAccountAccessTokenMapOutputWithContext(context.Context) ServiceAccountAccessTokenMapOutput +} + +type ServiceAccountAccessTokenMap map[string]ServiceAccountAccessTokenInput + +func (ServiceAccountAccessTokenMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccountAccessToken)(nil)).Elem() +} + +func (i ServiceAccountAccessTokenMap) ToServiceAccountAccessTokenMapOutput() ServiceAccountAccessTokenMapOutput { + return i.ToServiceAccountAccessTokenMapOutputWithContext(context.Background()) +} + +func (i ServiceAccountAccessTokenMap) ToServiceAccountAccessTokenMapOutputWithContext(ctx context.Context) ServiceAccountAccessTokenMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountAccessTokenMapOutput) +} + +type ServiceAccountAccessTokenOutput struct{ *pulumi.OutputState } + +func (ServiceAccountAccessTokenOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccountAccessToken)(nil)).Elem() +} + +func (o ServiceAccountAccessTokenOutput) ToServiceAccountAccessTokenOutput() ServiceAccountAccessTokenOutput { + return o +} + +func (o ServiceAccountAccessTokenOutput) ToServiceAccountAccessTokenOutputWithContext(ctx context.Context) ServiceAccountAccessTokenOutput { + return o +} + +// Identifier for the access token linked to the service account. +func (o ServiceAccountAccessTokenOutput) AccessTokenId() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.AccessTokenId }).(pulumi.StringOutput) +} + +// Indicate whether the token is currently active or inactive +func (o ServiceAccountAccessTokenOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.BoolOutput { return v.Active }).(pulumi.BoolOutput) +} + +// Timestamp indicating when the access token was created. +func (o ServiceAccountAccessTokenOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// STACKIT project ID associated with the service account token. +func (o ServiceAccountAccessTokenOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. +func (o ServiceAccountAccessTokenOutput) RotateWhenChanged() pulumi.StringMapOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringMapOutput { return v.RotateWhenChanged }).(pulumi.StringMapOutput) +} + +// Email address linked to the service account. +func (o ServiceAccountAccessTokenOutput) ServiceAccountEmail() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.ServiceAccountEmail }).(pulumi.StringOutput) +} + +// JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. +func (o ServiceAccountAccessTokenOutput) Token() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.Token }).(pulumi.StringOutput) +} + +// Specifies the token's validity duration in days. If unspecified, defaults to 90 days. +func (o ServiceAccountAccessTokenOutput) TtlDays() pulumi.IntOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.IntOutput { return v.TtlDays }).(pulumi.IntOutput) +} + +// Estimated expiration timestamp of the access token. For precise validity, check the JWT details. +func (o ServiceAccountAccessTokenOutput) ValidUntil() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountAccessToken) pulumi.StringOutput { return v.ValidUntil }).(pulumi.StringOutput) +} + +type ServiceAccountAccessTokenArrayOutput struct{ *pulumi.OutputState } + +func (ServiceAccountAccessTokenArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccountAccessToken)(nil)).Elem() +} + +func (o ServiceAccountAccessTokenArrayOutput) ToServiceAccountAccessTokenArrayOutput() ServiceAccountAccessTokenArrayOutput { + return o +} + +func (o ServiceAccountAccessTokenArrayOutput) ToServiceAccountAccessTokenArrayOutputWithContext(ctx context.Context) ServiceAccountAccessTokenArrayOutput { + return o +} + +func (o ServiceAccountAccessTokenArrayOutput) Index(i pulumi.IntInput) ServiceAccountAccessTokenOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccountAccessToken { + return vs[0].([]*ServiceAccountAccessToken)[vs[1].(int)] + }).(ServiceAccountAccessTokenOutput) +} + +type ServiceAccountAccessTokenMapOutput struct{ *pulumi.OutputState } + +func (ServiceAccountAccessTokenMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccountAccessToken)(nil)).Elem() +} + +func (o ServiceAccountAccessTokenMapOutput) ToServiceAccountAccessTokenMapOutput() ServiceAccountAccessTokenMapOutput { + return o +} + +func (o ServiceAccountAccessTokenMapOutput) ToServiceAccountAccessTokenMapOutputWithContext(ctx context.Context) ServiceAccountAccessTokenMapOutput { + return o +} + +func (o ServiceAccountAccessTokenMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountAccessTokenOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccountAccessToken { + return vs[0].(map[string]*ServiceAccountAccessToken)[vs[1].(string)] + }).(ServiceAccountAccessTokenOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountAccessTokenInput)(nil)).Elem(), &ServiceAccountAccessToken{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountAccessTokenArrayInput)(nil)).Elem(), ServiceAccountAccessTokenArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountAccessTokenMapInput)(nil)).Elem(), ServiceAccountAccessTokenMap{}) + pulumi.RegisterOutputType(ServiceAccountAccessTokenOutput{}) + pulumi.RegisterOutputType(ServiceAccountAccessTokenArrayOutput{}) + pulumi.RegisterOutputType(ServiceAccountAccessTokenMapOutput{}) +} diff --git a/sdk/go/stackit/serviceAccountKey.go b/sdk/go/stackit/serviceAccountKey.go new file mode 100644 index 0000000..621a714 --- /dev/null +++ b/sdk/go/stackit/serviceAccountKey.go @@ -0,0 +1,311 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Service account key schema. +// ## Example Usage +// +// ### Automatically rotate service account keys +type ServiceAccountKey struct { + pulumi.CustomResourceState + + // The raw JSON representation of the service account key json, available for direct use. + Json pulumi.StringOutput `pulumi:"json"` + // The unique identifier for the key associated with the service account. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // The STACKIT project ID associated with the service account key. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + PublicKey pulumi.StringPtrOutput `pulumi:"publicKey"` + // A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + RotateWhenChanged pulumi.StringMapOutput `pulumi:"rotateWhenChanged"` + // The email address associated with the service account, used for account identification and communication. + ServiceAccountEmail pulumi.StringOutput `pulumi:"serviceAccountEmail"` + // Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + TtlDays pulumi.IntPtrOutput `pulumi:"ttlDays"` +} + +// NewServiceAccountKey registers a new resource with the given unique name, arguments, and options. +func NewServiceAccountKey(ctx *pulumi.Context, + name string, args *ServiceAccountKeyArgs, opts ...pulumi.ResourceOption) (*ServiceAccountKey, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.ServiceAccountEmail == nil { + return nil, errors.New("invalid value for required argument 'ServiceAccountEmail'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "json", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ServiceAccountKey + err := ctx.RegisterResource("stackit:index/serviceAccountKey:ServiceAccountKey", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetServiceAccountKey gets an existing ServiceAccountKey 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 GetServiceAccountKey(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ServiceAccountKeyState, opts ...pulumi.ResourceOption) (*ServiceAccountKey, error) { + var resource ServiceAccountKey + err := ctx.ReadResource("stackit:index/serviceAccountKey:ServiceAccountKey", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ServiceAccountKey resources. +type serviceAccountKeyState struct { + // The raw JSON representation of the service account key json, available for direct use. + Json *string `pulumi:"json"` + // The unique identifier for the key associated with the service account. + KeyId *string `pulumi:"keyId"` + // The STACKIT project ID associated with the service account key. + ProjectId *string `pulumi:"projectId"` + // Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + PublicKey *string `pulumi:"publicKey"` + // A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // The email address associated with the service account, used for account identification and communication. + ServiceAccountEmail *string `pulumi:"serviceAccountEmail"` + // Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + TtlDays *int `pulumi:"ttlDays"` +} + +type ServiceAccountKeyState struct { + // The raw JSON representation of the service account key json, available for direct use. + Json pulumi.StringPtrInput + // The unique identifier for the key associated with the service account. + KeyId pulumi.StringPtrInput + // The STACKIT project ID associated with the service account key. + ProjectId pulumi.StringPtrInput + // Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + PublicKey pulumi.StringPtrInput + // A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + RotateWhenChanged pulumi.StringMapInput + // The email address associated with the service account, used for account identification and communication. + ServiceAccountEmail pulumi.StringPtrInput + // Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + TtlDays pulumi.IntPtrInput +} + +func (ServiceAccountKeyState) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountKeyState)(nil)).Elem() +} + +type serviceAccountKeyArgs struct { + // The STACKIT project ID associated with the service account key. + ProjectId string `pulumi:"projectId"` + // Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + PublicKey *string `pulumi:"publicKey"` + // A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + RotateWhenChanged map[string]string `pulumi:"rotateWhenChanged"` + // The email address associated with the service account, used for account identification and communication. + ServiceAccountEmail string `pulumi:"serviceAccountEmail"` + // Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + TtlDays *int `pulumi:"ttlDays"` +} + +// The set of arguments for constructing a ServiceAccountKey resource. +type ServiceAccountKeyArgs struct { + // The STACKIT project ID associated with the service account key. + ProjectId pulumi.StringInput + // Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + PublicKey pulumi.StringPtrInput + // A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + RotateWhenChanged pulumi.StringMapInput + // The email address associated with the service account, used for account identification and communication. + ServiceAccountEmail pulumi.StringInput + // Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + TtlDays pulumi.IntPtrInput +} + +func (ServiceAccountKeyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*serviceAccountKeyArgs)(nil)).Elem() +} + +type ServiceAccountKeyInput interface { + pulumi.Input + + ToServiceAccountKeyOutput() ServiceAccountKeyOutput + ToServiceAccountKeyOutputWithContext(ctx context.Context) ServiceAccountKeyOutput +} + +func (*ServiceAccountKey) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccountKey)(nil)).Elem() +} + +func (i *ServiceAccountKey) ToServiceAccountKeyOutput() ServiceAccountKeyOutput { + return i.ToServiceAccountKeyOutputWithContext(context.Background()) +} + +func (i *ServiceAccountKey) ToServiceAccountKeyOutputWithContext(ctx context.Context) ServiceAccountKeyOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountKeyOutput) +} + +// ServiceAccountKeyArrayInput is an input type that accepts ServiceAccountKeyArray and ServiceAccountKeyArrayOutput values. +// You can construct a concrete instance of `ServiceAccountKeyArrayInput` via: +// +// ServiceAccountKeyArray{ ServiceAccountKeyArgs{...} } +type ServiceAccountKeyArrayInput interface { + pulumi.Input + + ToServiceAccountKeyArrayOutput() ServiceAccountKeyArrayOutput + ToServiceAccountKeyArrayOutputWithContext(context.Context) ServiceAccountKeyArrayOutput +} + +type ServiceAccountKeyArray []ServiceAccountKeyInput + +func (ServiceAccountKeyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccountKey)(nil)).Elem() +} + +func (i ServiceAccountKeyArray) ToServiceAccountKeyArrayOutput() ServiceAccountKeyArrayOutput { + return i.ToServiceAccountKeyArrayOutputWithContext(context.Background()) +} + +func (i ServiceAccountKeyArray) ToServiceAccountKeyArrayOutputWithContext(ctx context.Context) ServiceAccountKeyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountKeyArrayOutput) +} + +// ServiceAccountKeyMapInput is an input type that accepts ServiceAccountKeyMap and ServiceAccountKeyMapOutput values. +// You can construct a concrete instance of `ServiceAccountKeyMapInput` via: +// +// ServiceAccountKeyMap{ "key": ServiceAccountKeyArgs{...} } +type ServiceAccountKeyMapInput interface { + pulumi.Input + + ToServiceAccountKeyMapOutput() ServiceAccountKeyMapOutput + ToServiceAccountKeyMapOutputWithContext(context.Context) ServiceAccountKeyMapOutput +} + +type ServiceAccountKeyMap map[string]ServiceAccountKeyInput + +func (ServiceAccountKeyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccountKey)(nil)).Elem() +} + +func (i ServiceAccountKeyMap) ToServiceAccountKeyMapOutput() ServiceAccountKeyMapOutput { + return i.ToServiceAccountKeyMapOutputWithContext(context.Background()) +} + +func (i ServiceAccountKeyMap) ToServiceAccountKeyMapOutputWithContext(ctx context.Context) ServiceAccountKeyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ServiceAccountKeyMapOutput) +} + +type ServiceAccountKeyOutput struct{ *pulumi.OutputState } + +func (ServiceAccountKeyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ServiceAccountKey)(nil)).Elem() +} + +func (o ServiceAccountKeyOutput) ToServiceAccountKeyOutput() ServiceAccountKeyOutput { + return o +} + +func (o ServiceAccountKeyOutput) ToServiceAccountKeyOutputWithContext(ctx context.Context) ServiceAccountKeyOutput { + return o +} + +// The raw JSON representation of the service account key json, available for direct use. +func (o ServiceAccountKeyOutput) Json() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringOutput { return v.Json }).(pulumi.StringOutput) +} + +// The unique identifier for the key associated with the service account. +func (o ServiceAccountKeyOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// The STACKIT project ID associated with the service account key. +func (o ServiceAccountKeyOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. +func (o ServiceAccountKeyOutput) PublicKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringPtrOutput { return v.PublicKey }).(pulumi.StringPtrOutput) +} + +// A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. +func (o ServiceAccountKeyOutput) RotateWhenChanged() pulumi.StringMapOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringMapOutput { return v.RotateWhenChanged }).(pulumi.StringMapOutput) +} + +// The email address associated with the service account, used for account identification and communication. +func (o ServiceAccountKeyOutput) ServiceAccountEmail() pulumi.StringOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.StringOutput { return v.ServiceAccountEmail }).(pulumi.StringOutput) +} + +// Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted +func (o ServiceAccountKeyOutput) TtlDays() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ServiceAccountKey) pulumi.IntPtrOutput { return v.TtlDays }).(pulumi.IntPtrOutput) +} + +type ServiceAccountKeyArrayOutput struct{ *pulumi.OutputState } + +func (ServiceAccountKeyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ServiceAccountKey)(nil)).Elem() +} + +func (o ServiceAccountKeyArrayOutput) ToServiceAccountKeyArrayOutput() ServiceAccountKeyArrayOutput { + return o +} + +func (o ServiceAccountKeyArrayOutput) ToServiceAccountKeyArrayOutputWithContext(ctx context.Context) ServiceAccountKeyArrayOutput { + return o +} + +func (o ServiceAccountKeyArrayOutput) Index(i pulumi.IntInput) ServiceAccountKeyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ServiceAccountKey { + return vs[0].([]*ServiceAccountKey)[vs[1].(int)] + }).(ServiceAccountKeyOutput) +} + +type ServiceAccountKeyMapOutput struct{ *pulumi.OutputState } + +func (ServiceAccountKeyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ServiceAccountKey)(nil)).Elem() +} + +func (o ServiceAccountKeyMapOutput) ToServiceAccountKeyMapOutput() ServiceAccountKeyMapOutput { + return o +} + +func (o ServiceAccountKeyMapOutput) ToServiceAccountKeyMapOutputWithContext(ctx context.Context) ServiceAccountKeyMapOutput { + return o +} + +func (o ServiceAccountKeyMapOutput) MapIndex(k pulumi.StringInput) ServiceAccountKeyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ServiceAccountKey { + return vs[0].(map[string]*ServiceAccountKey)[vs[1].(string)] + }).(ServiceAccountKeyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountKeyInput)(nil)).Elem(), &ServiceAccountKey{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountKeyArrayInput)(nil)).Elem(), ServiceAccountKeyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ServiceAccountKeyMapInput)(nil)).Elem(), ServiceAccountKeyMap{}) + pulumi.RegisterOutputType(ServiceAccountKeyOutput{}) + pulumi.RegisterOutputType(ServiceAccountKeyArrayOutput{}) + pulumi.RegisterOutputType(ServiceAccountKeyMapOutput{}) +} diff --git a/sdk/go/stackit/skeCluster.go b/sdk/go/stackit/skeCluster.go new file mode 100644 index 0000000..fb5fe65 --- /dev/null +++ b/sdk/go/stackit/skeCluster.go @@ -0,0 +1,422 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SKE Cluster Resource schema. Must have a `region` specified in the provider configuration. +// +// > When updating `nodePools` of a `SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied. +// +// ## Example Usage +type SkeCluster struct { + pulumi.CustomResourceState + + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // Deprecated as of Kubernetes 1.25 and later + AllowPrivilegedContainers pulumi.BoolPtrOutput `pulumi:"allowPrivilegedContainers"` + // The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + EgressAddressRanges pulumi.StringArrayOutput `pulumi:"egressAddressRanges"` + // A single extensions block as defined below. + Extensions SkeClusterExtensionsPtrOutput `pulumi:"extensions"` + // One or more hibernation block as defined below. + Hibernations SkeClusterHibernationArrayOutput `pulumi:"hibernations"` + // Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + // + // Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + KubernetesVersion pulumi.StringPtrOutput `pulumi:"kubernetesVersion"` + // The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + KubernetesVersionMin pulumi.StringPtrOutput `pulumi:"kubernetesVersionMin"` + // Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + KubernetesVersionUsed pulumi.StringOutput `pulumi:"kubernetesVersionUsed"` + // A single maintenance block as defined below. + Maintenance SkeClusterMaintenanceOutput `pulumi:"maintenance"` + // The cluster name. + Name pulumi.StringOutput `pulumi:"name"` + // Network block as defined below. + Network SkeClusterNetworkPtrOutput `pulumi:"network"` + // One or more `nodePool` block as defined below. + NodePools SkeClusterNodePoolArrayOutput `pulumi:"nodePools"` + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` +} + +// NewSkeCluster registers a new resource with the given unique name, arguments, and options. +func NewSkeCluster(ctx *pulumi.Context, + name string, args *SkeClusterArgs, opts ...pulumi.ResourceOption) (*SkeCluster, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.NodePools == nil { + return nil, errors.New("invalid value for required argument 'NodePools'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource SkeCluster + err := ctx.RegisterResource("stackit:index/skeCluster:SkeCluster", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSkeCluster gets an existing SkeCluster 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 GetSkeCluster(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SkeClusterState, opts ...pulumi.ResourceOption) (*SkeCluster, error) { + var resource SkeCluster + err := ctx.ReadResource("stackit:index/skeCluster:SkeCluster", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SkeCluster resources. +type skeClusterState struct { + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // Deprecated as of Kubernetes 1.25 and later + AllowPrivilegedContainers *bool `pulumi:"allowPrivilegedContainers"` + // The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + EgressAddressRanges []string `pulumi:"egressAddressRanges"` + // A single extensions block as defined below. + Extensions *SkeClusterExtensions `pulumi:"extensions"` + // One or more hibernation block as defined below. + Hibernations []SkeClusterHibernation `pulumi:"hibernations"` + // Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + // + // Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + KubernetesVersion *string `pulumi:"kubernetesVersion"` + // The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + KubernetesVersionMin *string `pulumi:"kubernetesVersionMin"` + // Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + KubernetesVersionUsed *string `pulumi:"kubernetesVersionUsed"` + // A single maintenance block as defined below. + Maintenance *SkeClusterMaintenance `pulumi:"maintenance"` + // The cluster name. + Name *string `pulumi:"name"` + // Network block as defined below. + Network *SkeClusterNetwork `pulumi:"network"` + // One or more `nodePool` block as defined below. + NodePools []SkeClusterNodePool `pulumi:"nodePools"` + // STACKIT project ID to which the cluster is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +type SkeClusterState struct { + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // Deprecated as of Kubernetes 1.25 and later + AllowPrivilegedContainers pulumi.BoolPtrInput + // The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + EgressAddressRanges pulumi.StringArrayInput + // A single extensions block as defined below. + Extensions SkeClusterExtensionsPtrInput + // One or more hibernation block as defined below. + Hibernations SkeClusterHibernationArrayInput + // Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + // + // Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + KubernetesVersion pulumi.StringPtrInput + // The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + KubernetesVersionMin pulumi.StringPtrInput + // Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + KubernetesVersionUsed pulumi.StringPtrInput + // A single maintenance block as defined below. + Maintenance SkeClusterMaintenancePtrInput + // The cluster name. + Name pulumi.StringPtrInput + // Network block as defined below. + Network SkeClusterNetworkPtrInput + // One or more `nodePool` block as defined below. + NodePools SkeClusterNodePoolArrayInput + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (SkeClusterState) ElementType() reflect.Type { + return reflect.TypeOf((*skeClusterState)(nil)).Elem() +} + +type skeClusterArgs struct { + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // Deprecated as of Kubernetes 1.25 and later + AllowPrivilegedContainers *bool `pulumi:"allowPrivilegedContainers"` + // A single extensions block as defined below. + Extensions *SkeClusterExtensions `pulumi:"extensions"` + // One or more hibernation block as defined below. + Hibernations []SkeClusterHibernation `pulumi:"hibernations"` + // Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + // + // Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + KubernetesVersion *string `pulumi:"kubernetesVersion"` + // The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + KubernetesVersionMin *string `pulumi:"kubernetesVersionMin"` + // A single maintenance block as defined below. + Maintenance *SkeClusterMaintenance `pulumi:"maintenance"` + // The cluster name. + Name *string `pulumi:"name"` + // Network block as defined below. + Network *SkeClusterNetwork `pulumi:"network"` + // One or more `nodePool` block as defined below. + NodePools []SkeClusterNodePool `pulumi:"nodePools"` + // STACKIT project ID to which the cluster is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` +} + +// The set of arguments for constructing a SkeCluster resource. +type SkeClusterArgs struct { + // Flag to specify if privileged mode for containers is enabled or not. + // This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + // Deprecated as of Kubernetes 1.25 and later + AllowPrivilegedContainers pulumi.BoolPtrInput + // A single extensions block as defined below. + Extensions SkeClusterExtensionsPtrInput + // One or more hibernation block as defined below. + Hibernations SkeClusterHibernationArrayInput + // Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + // + // Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + KubernetesVersion pulumi.StringPtrInput + // The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + KubernetesVersionMin pulumi.StringPtrInput + // A single maintenance block as defined below. + Maintenance SkeClusterMaintenancePtrInput + // The cluster name. + Name pulumi.StringPtrInput + // Network block as defined below. + Network SkeClusterNetworkPtrInput + // One or more `nodePool` block as defined below. + NodePools SkeClusterNodePoolArrayInput + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput +} + +func (SkeClusterArgs) ElementType() reflect.Type { + return reflect.TypeOf((*skeClusterArgs)(nil)).Elem() +} + +type SkeClusterInput interface { + pulumi.Input + + ToSkeClusterOutput() SkeClusterOutput + ToSkeClusterOutputWithContext(ctx context.Context) SkeClusterOutput +} + +func (*SkeCluster) ElementType() reflect.Type { + return reflect.TypeOf((**SkeCluster)(nil)).Elem() +} + +func (i *SkeCluster) ToSkeClusterOutput() SkeClusterOutput { + return i.ToSkeClusterOutputWithContext(context.Background()) +} + +func (i *SkeCluster) ToSkeClusterOutputWithContext(ctx context.Context) SkeClusterOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterOutput) +} + +// SkeClusterArrayInput is an input type that accepts SkeClusterArray and SkeClusterArrayOutput values. +// You can construct a concrete instance of `SkeClusterArrayInput` via: +// +// SkeClusterArray{ SkeClusterArgs{...} } +type SkeClusterArrayInput interface { + pulumi.Input + + ToSkeClusterArrayOutput() SkeClusterArrayOutput + ToSkeClusterArrayOutputWithContext(context.Context) SkeClusterArrayOutput +} + +type SkeClusterArray []SkeClusterInput + +func (SkeClusterArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SkeCluster)(nil)).Elem() +} + +func (i SkeClusterArray) ToSkeClusterArrayOutput() SkeClusterArrayOutput { + return i.ToSkeClusterArrayOutputWithContext(context.Background()) +} + +func (i SkeClusterArray) ToSkeClusterArrayOutputWithContext(ctx context.Context) SkeClusterArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterArrayOutput) +} + +// SkeClusterMapInput is an input type that accepts SkeClusterMap and SkeClusterMapOutput values. +// You can construct a concrete instance of `SkeClusterMapInput` via: +// +// SkeClusterMap{ "key": SkeClusterArgs{...} } +type SkeClusterMapInput interface { + pulumi.Input + + ToSkeClusterMapOutput() SkeClusterMapOutput + ToSkeClusterMapOutputWithContext(context.Context) SkeClusterMapOutput +} + +type SkeClusterMap map[string]SkeClusterInput + +func (SkeClusterMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SkeCluster)(nil)).Elem() +} + +func (i SkeClusterMap) ToSkeClusterMapOutput() SkeClusterMapOutput { + return i.ToSkeClusterMapOutputWithContext(context.Background()) +} + +func (i SkeClusterMap) ToSkeClusterMapOutputWithContext(ctx context.Context) SkeClusterMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeClusterMapOutput) +} + +type SkeClusterOutput struct{ *pulumi.OutputState } + +func (SkeClusterOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeCluster)(nil)).Elem() +} + +func (o SkeClusterOutput) ToSkeClusterOutput() SkeClusterOutput { + return o +} + +func (o SkeClusterOutput) ToSkeClusterOutputWithContext(ctx context.Context) SkeClusterOutput { + return o +} + +// Flag to specify if privileged mode for containers is enabled or not. +// This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). +// Deprecated as of Kubernetes 1.25 and later +func (o SkeClusterOutput) AllowPrivilegedContainers() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.BoolPtrOutput { return v.AllowPrivilegedContainers }).(pulumi.BoolPtrOutput) +} + +// The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. +func (o SkeClusterOutput) EgressAddressRanges() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringArrayOutput { return v.EgressAddressRanges }).(pulumi.StringArrayOutput) +} + +// A single extensions block as defined below. +func (o SkeClusterOutput) Extensions() SkeClusterExtensionsPtrOutput { + return o.ApplyT(func(v *SkeCluster) SkeClusterExtensionsPtrOutput { return v.Extensions }).(SkeClusterExtensionsPtrOutput) +} + +// One or more hibernation block as defined below. +func (o SkeClusterOutput) Hibernations() SkeClusterHibernationArrayOutput { + return o.ApplyT(func(v *SkeCluster) SkeClusterHibernationArrayOutput { return v.Hibernations }).(SkeClusterHibernationArrayOutput) +} + +// Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` +// +// Deprecated: Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. +func (o SkeClusterOutput) KubernetesVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringPtrOutput { return v.KubernetesVersion }).(pulumi.StringPtrOutput) +} + +// The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. +func (o SkeClusterOutput) KubernetesVersionMin() pulumi.StringPtrOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringPtrOutput { return v.KubernetesVersionMin }).(pulumi.StringPtrOutput) +} + +// Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). +func (o SkeClusterOutput) KubernetesVersionUsed() pulumi.StringOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringOutput { return v.KubernetesVersionUsed }).(pulumi.StringOutput) +} + +// A single maintenance block as defined below. +func (o SkeClusterOutput) Maintenance() SkeClusterMaintenanceOutput { + return o.ApplyT(func(v *SkeCluster) SkeClusterMaintenanceOutput { return v.Maintenance }).(SkeClusterMaintenanceOutput) +} + +// The cluster name. +func (o SkeClusterOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Network block as defined below. +func (o SkeClusterOutput) Network() SkeClusterNetworkPtrOutput { + return o.ApplyT(func(v *SkeCluster) SkeClusterNetworkPtrOutput { return v.Network }).(SkeClusterNetworkPtrOutput) +} + +// One or more `nodePool` block as defined below. +func (o SkeClusterOutput) NodePools() SkeClusterNodePoolArrayOutput { + return o.ApplyT(func(v *SkeCluster) SkeClusterNodePoolArrayOutput { return v.NodePools }).(SkeClusterNodePoolArrayOutput) +} + +// STACKIT project ID to which the cluster is associated. +func (o SkeClusterOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o SkeClusterOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *SkeCluster) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +type SkeClusterArrayOutput struct{ *pulumi.OutputState } + +func (SkeClusterArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SkeCluster)(nil)).Elem() +} + +func (o SkeClusterArrayOutput) ToSkeClusterArrayOutput() SkeClusterArrayOutput { + return o +} + +func (o SkeClusterArrayOutput) ToSkeClusterArrayOutputWithContext(ctx context.Context) SkeClusterArrayOutput { + return o +} + +func (o SkeClusterArrayOutput) Index(i pulumi.IntInput) SkeClusterOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SkeCluster { + return vs[0].([]*SkeCluster)[vs[1].(int)] + }).(SkeClusterOutput) +} + +type SkeClusterMapOutput struct{ *pulumi.OutputState } + +func (SkeClusterMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SkeCluster)(nil)).Elem() +} + +func (o SkeClusterMapOutput) ToSkeClusterMapOutput() SkeClusterMapOutput { + return o +} + +func (o SkeClusterMapOutput) ToSkeClusterMapOutputWithContext(ctx context.Context) SkeClusterMapOutput { + return o +} + +func (o SkeClusterMapOutput) MapIndex(k pulumi.StringInput) SkeClusterOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SkeCluster { + return vs[0].(map[string]*SkeCluster)[vs[1].(string)] + }).(SkeClusterOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterInput)(nil)).Elem(), &SkeCluster{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterArrayInput)(nil)).Elem(), SkeClusterArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeClusterMapInput)(nil)).Elem(), SkeClusterMap{}) + pulumi.RegisterOutputType(SkeClusterOutput{}) + pulumi.RegisterOutputType(SkeClusterArrayOutput{}) + pulumi.RegisterOutputType(SkeClusterMapOutput{}) +} diff --git a/sdk/go/stackit/skeKubeconfig.go b/sdk/go/stackit/skeKubeconfig.go new file mode 100644 index 0000000..510f794 --- /dev/null +++ b/sdk/go/stackit/skeKubeconfig.go @@ -0,0 +1,313 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SkeKubeconfig struct { + pulumi.CustomResourceState + + // Name of the SKE cluster. + ClusterName pulumi.StringOutput `pulumi:"clusterName"` + // Date-time when the kubeconfig was created + CreationTime pulumi.StringOutput `pulumi:"creationTime"` + // Expiration time of the kubeconfig, in seconds. Defaults to `3600` + Expiration pulumi.IntOutput `pulumi:"expiration"` + // Timestamp when the kubeconfig expires + ExpiresAt pulumi.StringOutput `pulumi:"expiresAt"` + // Raw short-lived admin kubeconfig. + KubeConfig pulumi.StringOutput `pulumi:"kubeConfig"` + KubeConfigId pulumi.StringOutput `pulumi:"kubeConfigId"` + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + Refresh pulumi.BoolPtrOutput `pulumi:"refresh"` +} + +// NewSkeKubeconfig registers a new resource with the given unique name, arguments, and options. +func NewSkeKubeconfig(ctx *pulumi.Context, + name string, args *SkeKubeconfigArgs, opts ...pulumi.ResourceOption) (*SkeKubeconfig, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ClusterName == nil { + return nil, errors.New("invalid value for required argument 'ClusterName'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "kubeConfig", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource SkeKubeconfig + err := ctx.RegisterResource("stackit:index/skeKubeconfig:SkeKubeconfig", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSkeKubeconfig gets an existing SkeKubeconfig 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 GetSkeKubeconfig(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SkeKubeconfigState, opts ...pulumi.ResourceOption) (*SkeKubeconfig, error) { + var resource SkeKubeconfig + err := ctx.ReadResource("stackit:index/skeKubeconfig:SkeKubeconfig", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SkeKubeconfig resources. +type skeKubeconfigState struct { + // Name of the SKE cluster. + ClusterName *string `pulumi:"clusterName"` + // Date-time when the kubeconfig was created + CreationTime *string `pulumi:"creationTime"` + // Expiration time of the kubeconfig, in seconds. Defaults to `3600` + Expiration *int `pulumi:"expiration"` + // Timestamp when the kubeconfig expires + ExpiresAt *string `pulumi:"expiresAt"` + // Raw short-lived admin kubeconfig. + KubeConfig *string `pulumi:"kubeConfig"` + KubeConfigId *string `pulumi:"kubeConfigId"` + // STACKIT project ID to which the cluster is associated. + ProjectId *string `pulumi:"projectId"` + // If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + Refresh *bool `pulumi:"refresh"` +} + +type SkeKubeconfigState struct { + // Name of the SKE cluster. + ClusterName pulumi.StringPtrInput + // Date-time when the kubeconfig was created + CreationTime pulumi.StringPtrInput + // Expiration time of the kubeconfig, in seconds. Defaults to `3600` + Expiration pulumi.IntPtrInput + // Timestamp when the kubeconfig expires + ExpiresAt pulumi.StringPtrInput + // Raw short-lived admin kubeconfig. + KubeConfig pulumi.StringPtrInput + KubeConfigId pulumi.StringPtrInput + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringPtrInput + // If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + Refresh pulumi.BoolPtrInput +} + +func (SkeKubeconfigState) ElementType() reflect.Type { + return reflect.TypeOf((*skeKubeconfigState)(nil)).Elem() +} + +type skeKubeconfigArgs struct { + // Name of the SKE cluster. + ClusterName string `pulumi:"clusterName"` + // Expiration time of the kubeconfig, in seconds. Defaults to `3600` + Expiration *int `pulumi:"expiration"` + // STACKIT project ID to which the cluster is associated. + ProjectId string `pulumi:"projectId"` + // If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + Refresh *bool `pulumi:"refresh"` +} + +// The set of arguments for constructing a SkeKubeconfig resource. +type SkeKubeconfigArgs struct { + // Name of the SKE cluster. + ClusterName pulumi.StringInput + // Expiration time of the kubeconfig, in seconds. Defaults to `3600` + Expiration pulumi.IntPtrInput + // STACKIT project ID to which the cluster is associated. + ProjectId pulumi.StringInput + // If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + Refresh pulumi.BoolPtrInput +} + +func (SkeKubeconfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*skeKubeconfigArgs)(nil)).Elem() +} + +type SkeKubeconfigInput interface { + pulumi.Input + + ToSkeKubeconfigOutput() SkeKubeconfigOutput + ToSkeKubeconfigOutputWithContext(ctx context.Context) SkeKubeconfigOutput +} + +func (*SkeKubeconfig) ElementType() reflect.Type { + return reflect.TypeOf((**SkeKubeconfig)(nil)).Elem() +} + +func (i *SkeKubeconfig) ToSkeKubeconfigOutput() SkeKubeconfigOutput { + return i.ToSkeKubeconfigOutputWithContext(context.Background()) +} + +func (i *SkeKubeconfig) ToSkeKubeconfigOutputWithContext(ctx context.Context) SkeKubeconfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeKubeconfigOutput) +} + +// SkeKubeconfigArrayInput is an input type that accepts SkeKubeconfigArray and SkeKubeconfigArrayOutput values. +// You can construct a concrete instance of `SkeKubeconfigArrayInput` via: +// +// SkeKubeconfigArray{ SkeKubeconfigArgs{...} } +type SkeKubeconfigArrayInput interface { + pulumi.Input + + ToSkeKubeconfigArrayOutput() SkeKubeconfigArrayOutput + ToSkeKubeconfigArrayOutputWithContext(context.Context) SkeKubeconfigArrayOutput +} + +type SkeKubeconfigArray []SkeKubeconfigInput + +func (SkeKubeconfigArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SkeKubeconfig)(nil)).Elem() +} + +func (i SkeKubeconfigArray) ToSkeKubeconfigArrayOutput() SkeKubeconfigArrayOutput { + return i.ToSkeKubeconfigArrayOutputWithContext(context.Background()) +} + +func (i SkeKubeconfigArray) ToSkeKubeconfigArrayOutputWithContext(ctx context.Context) SkeKubeconfigArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeKubeconfigArrayOutput) +} + +// SkeKubeconfigMapInput is an input type that accepts SkeKubeconfigMap and SkeKubeconfigMapOutput values. +// You can construct a concrete instance of `SkeKubeconfigMapInput` via: +// +// SkeKubeconfigMap{ "key": SkeKubeconfigArgs{...} } +type SkeKubeconfigMapInput interface { + pulumi.Input + + ToSkeKubeconfigMapOutput() SkeKubeconfigMapOutput + ToSkeKubeconfigMapOutputWithContext(context.Context) SkeKubeconfigMapOutput +} + +type SkeKubeconfigMap map[string]SkeKubeconfigInput + +func (SkeKubeconfigMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SkeKubeconfig)(nil)).Elem() +} + +func (i SkeKubeconfigMap) ToSkeKubeconfigMapOutput() SkeKubeconfigMapOutput { + return i.ToSkeKubeconfigMapOutputWithContext(context.Background()) +} + +func (i SkeKubeconfigMap) ToSkeKubeconfigMapOutputWithContext(ctx context.Context) SkeKubeconfigMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SkeKubeconfigMapOutput) +} + +type SkeKubeconfigOutput struct{ *pulumi.OutputState } + +func (SkeKubeconfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SkeKubeconfig)(nil)).Elem() +} + +func (o SkeKubeconfigOutput) ToSkeKubeconfigOutput() SkeKubeconfigOutput { + return o +} + +func (o SkeKubeconfigOutput) ToSkeKubeconfigOutputWithContext(ctx context.Context) SkeKubeconfigOutput { + return o +} + +// Name of the SKE cluster. +func (o SkeKubeconfigOutput) ClusterName() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.ClusterName }).(pulumi.StringOutput) +} + +// Date-time when the kubeconfig was created +func (o SkeKubeconfigOutput) CreationTime() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.CreationTime }).(pulumi.StringOutput) +} + +// Expiration time of the kubeconfig, in seconds. Defaults to `3600` +func (o SkeKubeconfigOutput) Expiration() pulumi.IntOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.IntOutput { return v.Expiration }).(pulumi.IntOutput) +} + +// Timestamp when the kubeconfig expires +func (o SkeKubeconfigOutput) ExpiresAt() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.ExpiresAt }).(pulumi.StringOutput) +} + +// Raw short-lived admin kubeconfig. +func (o SkeKubeconfigOutput) KubeConfig() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.KubeConfig }).(pulumi.StringOutput) +} + +func (o SkeKubeconfigOutput) KubeConfigId() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.KubeConfigId }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the cluster is associated. +func (o SkeKubeconfigOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place +func (o SkeKubeconfigOutput) Refresh() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *SkeKubeconfig) pulumi.BoolPtrOutput { return v.Refresh }).(pulumi.BoolPtrOutput) +} + +type SkeKubeconfigArrayOutput struct{ *pulumi.OutputState } + +func (SkeKubeconfigArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SkeKubeconfig)(nil)).Elem() +} + +func (o SkeKubeconfigArrayOutput) ToSkeKubeconfigArrayOutput() SkeKubeconfigArrayOutput { + return o +} + +func (o SkeKubeconfigArrayOutput) ToSkeKubeconfigArrayOutputWithContext(ctx context.Context) SkeKubeconfigArrayOutput { + return o +} + +func (o SkeKubeconfigArrayOutput) Index(i pulumi.IntInput) SkeKubeconfigOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SkeKubeconfig { + return vs[0].([]*SkeKubeconfig)[vs[1].(int)] + }).(SkeKubeconfigOutput) +} + +type SkeKubeconfigMapOutput struct{ *pulumi.OutputState } + +func (SkeKubeconfigMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SkeKubeconfig)(nil)).Elem() +} + +func (o SkeKubeconfigMapOutput) ToSkeKubeconfigMapOutput() SkeKubeconfigMapOutput { + return o +} + +func (o SkeKubeconfigMapOutput) ToSkeKubeconfigMapOutputWithContext(ctx context.Context) SkeKubeconfigMapOutput { + return o +} + +func (o SkeKubeconfigMapOutput) MapIndex(k pulumi.StringInput) SkeKubeconfigOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SkeKubeconfig { + return vs[0].(map[string]*SkeKubeconfig)[vs[1].(string)] + }).(SkeKubeconfigOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SkeKubeconfigInput)(nil)).Elem(), &SkeKubeconfig{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeKubeconfigArrayInput)(nil)).Elem(), SkeKubeconfigArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SkeKubeconfigMapInput)(nil)).Elem(), SkeKubeconfigMap{}) + pulumi.RegisterOutputType(SkeKubeconfigOutput{}) + pulumi.RegisterOutputType(SkeKubeconfigArrayOutput{}) + pulumi.RegisterOutputType(SkeKubeconfigMapOutput{}) +} diff --git a/sdk/go/stackit/sqlserverflexInstance.go b/sdk/go/stackit/sqlserverflexInstance.go new file mode 100644 index 0000000..87e22a8 --- /dev/null +++ b/sdk/go/stackit/sqlserverflexInstance.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SqlserverflexInstance struct { + pulumi.CustomResourceState + + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls pulumi.StringArrayOutput `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + BackupSchedule pulumi.StringOutput `pulumi:"backupSchedule"` + Flavor SqlserverflexInstanceFlavorOutput `pulumi:"flavor"` + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Instance name. + Name pulumi.StringOutput `pulumi:"name"` + Options SqlserverflexInstanceOptionsOutput `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region pulumi.StringOutput `pulumi:"region"` + Replicas pulumi.IntOutput `pulumi:"replicas"` + Storage SqlserverflexInstanceStorageOutput `pulumi:"storage"` + Version pulumi.StringOutput `pulumi:"version"` +} + +// NewSqlserverflexInstance registers a new resource with the given unique name, arguments, and options. +func NewSqlserverflexInstance(ctx *pulumi.Context, + name string, args *SqlserverflexInstanceArgs, opts ...pulumi.ResourceOption) (*SqlserverflexInstance, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Flavor == nil { + return nil, errors.New("invalid value for required argument 'Flavor'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource SqlserverflexInstance + err := ctx.RegisterResource("stackit:index/sqlserverflexInstance:SqlserverflexInstance", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSqlserverflexInstance gets an existing SqlserverflexInstance 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 GetSqlserverflexInstance(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SqlserverflexInstanceState, opts ...pulumi.ResourceOption) (*SqlserverflexInstance, error) { + var resource SqlserverflexInstance + err := ctx.ReadResource("stackit:index/sqlserverflexInstance:SqlserverflexInstance", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SqlserverflexInstance resources. +type sqlserverflexInstanceState struct { + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + BackupSchedule *string `pulumi:"backupSchedule"` + Flavor *SqlserverflexInstanceFlavor `pulumi:"flavor"` + // ID of the SQLServer Flex instance. + InstanceId *string `pulumi:"instanceId"` + // Instance name. + Name *string `pulumi:"name"` + Options *SqlserverflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Replicas *int `pulumi:"replicas"` + Storage *SqlserverflexInstanceStorage `pulumi:"storage"` + Version *string `pulumi:"version"` +} + +type SqlserverflexInstanceState struct { + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls pulumi.StringArrayInput + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + BackupSchedule pulumi.StringPtrInput + Flavor SqlserverflexInstanceFlavorPtrInput + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringPtrInput + // Instance name. + Name pulumi.StringPtrInput + Options SqlserverflexInstanceOptionsPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + Replicas pulumi.IntPtrInput + Storage SqlserverflexInstanceStoragePtrInput + Version pulumi.StringPtrInput +} + +func (SqlserverflexInstanceState) ElementType() reflect.Type { + return reflect.TypeOf((*sqlserverflexInstanceState)(nil)).Elem() +} + +type sqlserverflexInstanceArgs struct { + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls []string `pulumi:"acls"` + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + BackupSchedule *string `pulumi:"backupSchedule"` + Flavor SqlserverflexInstanceFlavor `pulumi:"flavor"` + // Instance name. + Name *string `pulumi:"name"` + Options *SqlserverflexInstanceOptions `pulumi:"options"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + // The resource region. If not defined, the provider region is used. + Region *string `pulumi:"region"` + Storage *SqlserverflexInstanceStorage `pulumi:"storage"` + Version *string `pulumi:"version"` +} + +// The set of arguments for constructing a SqlserverflexInstance resource. +type SqlserverflexInstanceArgs struct { + // The Access Control List (ACL) for the SQLServer Flex instance. + Acls pulumi.StringArrayInput + // The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + BackupSchedule pulumi.StringPtrInput + Flavor SqlserverflexInstanceFlavorInput + // Instance name. + Name pulumi.StringPtrInput + Options SqlserverflexInstanceOptionsPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + // The resource region. If not defined, the provider region is used. + Region pulumi.StringPtrInput + Storage SqlserverflexInstanceStoragePtrInput + Version pulumi.StringPtrInput +} + +func (SqlserverflexInstanceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*sqlserverflexInstanceArgs)(nil)).Elem() +} + +type SqlserverflexInstanceInput interface { + pulumi.Input + + ToSqlserverflexInstanceOutput() SqlserverflexInstanceOutput + ToSqlserverflexInstanceOutputWithContext(ctx context.Context) SqlserverflexInstanceOutput +} + +func (*SqlserverflexInstance) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstance)(nil)).Elem() +} + +func (i *SqlserverflexInstance) ToSqlserverflexInstanceOutput() SqlserverflexInstanceOutput { + return i.ToSqlserverflexInstanceOutputWithContext(context.Background()) +} + +func (i *SqlserverflexInstance) ToSqlserverflexInstanceOutputWithContext(ctx context.Context) SqlserverflexInstanceOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceOutput) +} + +// SqlserverflexInstanceArrayInput is an input type that accepts SqlserverflexInstanceArray and SqlserverflexInstanceArrayOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceArrayInput` via: +// +// SqlserverflexInstanceArray{ SqlserverflexInstanceArgs{...} } +type SqlserverflexInstanceArrayInput interface { + pulumi.Input + + ToSqlserverflexInstanceArrayOutput() SqlserverflexInstanceArrayOutput + ToSqlserverflexInstanceArrayOutputWithContext(context.Context) SqlserverflexInstanceArrayOutput +} + +type SqlserverflexInstanceArray []SqlserverflexInstanceInput + +func (SqlserverflexInstanceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SqlserverflexInstance)(nil)).Elem() +} + +func (i SqlserverflexInstanceArray) ToSqlserverflexInstanceArrayOutput() SqlserverflexInstanceArrayOutput { + return i.ToSqlserverflexInstanceArrayOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceArray) ToSqlserverflexInstanceArrayOutputWithContext(ctx context.Context) SqlserverflexInstanceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceArrayOutput) +} + +// SqlserverflexInstanceMapInput is an input type that accepts SqlserverflexInstanceMap and SqlserverflexInstanceMapOutput values. +// You can construct a concrete instance of `SqlserverflexInstanceMapInput` via: +// +// SqlserverflexInstanceMap{ "key": SqlserverflexInstanceArgs{...} } +type SqlserverflexInstanceMapInput interface { + pulumi.Input + + ToSqlserverflexInstanceMapOutput() SqlserverflexInstanceMapOutput + ToSqlserverflexInstanceMapOutputWithContext(context.Context) SqlserverflexInstanceMapOutput +} + +type SqlserverflexInstanceMap map[string]SqlserverflexInstanceInput + +func (SqlserverflexInstanceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SqlserverflexInstance)(nil)).Elem() +} + +func (i SqlserverflexInstanceMap) ToSqlserverflexInstanceMapOutput() SqlserverflexInstanceMapOutput { + return i.ToSqlserverflexInstanceMapOutputWithContext(context.Background()) +} + +func (i SqlserverflexInstanceMap) ToSqlserverflexInstanceMapOutputWithContext(ctx context.Context) SqlserverflexInstanceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexInstanceMapOutput) +} + +type SqlserverflexInstanceOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexInstance)(nil)).Elem() +} + +func (o SqlserverflexInstanceOutput) ToSqlserverflexInstanceOutput() SqlserverflexInstanceOutput { + return o +} + +func (o SqlserverflexInstanceOutput) ToSqlserverflexInstanceOutputWithContext(ctx context.Context) SqlserverflexInstanceOutput { + return o +} + +// The Access Control List (ACL) for the SQLServer Flex instance. +func (o SqlserverflexInstanceOutput) Acls() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringArrayOutput { return v.Acls }).(pulumi.StringArrayOutput) +} + +// The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") +func (o SqlserverflexInstanceOutput) BackupSchedule() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.BackupSchedule }).(pulumi.StringOutput) +} + +func (o SqlserverflexInstanceOutput) Flavor() SqlserverflexInstanceFlavorOutput { + return o.ApplyT(func(v *SqlserverflexInstance) SqlserverflexInstanceFlavorOutput { return v.Flavor }).(SqlserverflexInstanceFlavorOutput) +} + +// ID of the SQLServer Flex instance. +func (o SqlserverflexInstanceOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Instance name. +func (o SqlserverflexInstanceOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +func (o SqlserverflexInstanceOutput) Options() SqlserverflexInstanceOptionsOutput { + return o.ApplyT(func(v *SqlserverflexInstance) SqlserverflexInstanceOptionsOutput { return v.Options }).(SqlserverflexInstanceOptionsOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o SqlserverflexInstanceOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The resource region. If not defined, the provider region is used. +func (o SqlserverflexInstanceOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +func (o SqlserverflexInstanceOutput) Replicas() pulumi.IntOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.IntOutput { return v.Replicas }).(pulumi.IntOutput) +} + +func (o SqlserverflexInstanceOutput) Storage() SqlserverflexInstanceStorageOutput { + return o.ApplyT(func(v *SqlserverflexInstance) SqlserverflexInstanceStorageOutput { return v.Storage }).(SqlserverflexInstanceStorageOutput) +} + +func (o SqlserverflexInstanceOutput) Version() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexInstance) pulumi.StringOutput { return v.Version }).(pulumi.StringOutput) +} + +type SqlserverflexInstanceArrayOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SqlserverflexInstance)(nil)).Elem() +} + +func (o SqlserverflexInstanceArrayOutput) ToSqlserverflexInstanceArrayOutput() SqlserverflexInstanceArrayOutput { + return o +} + +func (o SqlserverflexInstanceArrayOutput) ToSqlserverflexInstanceArrayOutputWithContext(ctx context.Context) SqlserverflexInstanceArrayOutput { + return o +} + +func (o SqlserverflexInstanceArrayOutput) Index(i pulumi.IntInput) SqlserverflexInstanceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SqlserverflexInstance { + return vs[0].([]*SqlserverflexInstance)[vs[1].(int)] + }).(SqlserverflexInstanceOutput) +} + +type SqlserverflexInstanceMapOutput struct{ *pulumi.OutputState } + +func (SqlserverflexInstanceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SqlserverflexInstance)(nil)).Elem() +} + +func (o SqlserverflexInstanceMapOutput) ToSqlserverflexInstanceMapOutput() SqlserverflexInstanceMapOutput { + return o +} + +func (o SqlserverflexInstanceMapOutput) ToSqlserverflexInstanceMapOutputWithContext(ctx context.Context) SqlserverflexInstanceMapOutput { + return o +} + +func (o SqlserverflexInstanceMapOutput) MapIndex(k pulumi.StringInput) SqlserverflexInstanceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SqlserverflexInstance { + return vs[0].(map[string]*SqlserverflexInstance)[vs[1].(string)] + }).(SqlserverflexInstanceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceInput)(nil)).Elem(), &SqlserverflexInstance{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceArrayInput)(nil)).Elem(), SqlserverflexInstanceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexInstanceMapInput)(nil)).Elem(), SqlserverflexInstanceMap{}) + pulumi.RegisterOutputType(SqlserverflexInstanceOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceArrayOutput{}) + pulumi.RegisterOutputType(SqlserverflexInstanceMapOutput{}) +} diff --git a/sdk/go/stackit/sqlserverflexUser.go b/sdk/go/stackit/sqlserverflexUser.go new file mode 100644 index 0000000..a53bb2c --- /dev/null +++ b/sdk/go/stackit/sqlserverflexUser.go @@ -0,0 +1,321 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type SqlserverflexUser struct { + pulumi.CustomResourceState + + Host pulumi.StringOutput `pulumi:"host"` + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringOutput `pulumi:"instanceId"` + // Password of the user account. + Password pulumi.StringOutput `pulumi:"password"` + Port pulumi.IntOutput `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + Region pulumi.StringOutput `pulumi:"region"` + // Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + Roles pulumi.StringArrayOutput `pulumi:"roles"` + // User ID. + UserId pulumi.StringOutput `pulumi:"userId"` + // Username of the SQLServer Flex instance. + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewSqlserverflexUser registers a new resource with the given unique name, arguments, and options. +func NewSqlserverflexUser(ctx *pulumi.Context, + name string, args *SqlserverflexUserArgs, opts ...pulumi.ResourceOption) (*SqlserverflexUser, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstanceId == nil { + return nil, errors.New("invalid value for required argument 'InstanceId'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "password", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource SqlserverflexUser + err := ctx.RegisterResource("stackit:index/sqlserverflexUser:SqlserverflexUser", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetSqlserverflexUser gets an existing SqlserverflexUser 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 GetSqlserverflexUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *SqlserverflexUserState, opts ...pulumi.ResourceOption) (*SqlserverflexUser, error) { + var resource SqlserverflexUser + err := ctx.ReadResource("stackit:index/sqlserverflexUser:SqlserverflexUser", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering SqlserverflexUser resources. +type sqlserverflexUserState struct { + Host *string `pulumi:"host"` + // ID of the SQLServer Flex instance. + InstanceId *string `pulumi:"instanceId"` + // Password of the user account. + Password *string `pulumi:"password"` + Port *int `pulumi:"port"` + // STACKIT project ID to which the instance is associated. + ProjectId *string `pulumi:"projectId"` + Region *string `pulumi:"region"` + // Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + Roles []string `pulumi:"roles"` + // User ID. + UserId *string `pulumi:"userId"` + // Username of the SQLServer Flex instance. + Username *string `pulumi:"username"` +} + +type SqlserverflexUserState struct { + Host pulumi.StringPtrInput + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringPtrInput + // Password of the user account. + Password pulumi.StringPtrInput + Port pulumi.IntPtrInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringPtrInput + Region pulumi.StringPtrInput + // Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + Roles pulumi.StringArrayInput + // User ID. + UserId pulumi.StringPtrInput + // Username of the SQLServer Flex instance. + Username pulumi.StringPtrInput +} + +func (SqlserverflexUserState) ElementType() reflect.Type { + return reflect.TypeOf((*sqlserverflexUserState)(nil)).Elem() +} + +type sqlserverflexUserArgs struct { + // ID of the SQLServer Flex instance. + InstanceId string `pulumi:"instanceId"` + // STACKIT project ID to which the instance is associated. + ProjectId string `pulumi:"projectId"` + Region *string `pulumi:"region"` + // Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + Roles []string `pulumi:"roles"` + // Username of the SQLServer Flex instance. + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a SqlserverflexUser resource. +type SqlserverflexUserArgs struct { + // ID of the SQLServer Flex instance. + InstanceId pulumi.StringInput + // STACKIT project ID to which the instance is associated. + ProjectId pulumi.StringInput + Region pulumi.StringPtrInput + // Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + Roles pulumi.StringArrayInput + // Username of the SQLServer Flex instance. + Username pulumi.StringInput +} + +func (SqlserverflexUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*sqlserverflexUserArgs)(nil)).Elem() +} + +type SqlserverflexUserInput interface { + pulumi.Input + + ToSqlserverflexUserOutput() SqlserverflexUserOutput + ToSqlserverflexUserOutputWithContext(ctx context.Context) SqlserverflexUserOutput +} + +func (*SqlserverflexUser) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexUser)(nil)).Elem() +} + +func (i *SqlserverflexUser) ToSqlserverflexUserOutput() SqlserverflexUserOutput { + return i.ToSqlserverflexUserOutputWithContext(context.Background()) +} + +func (i *SqlserverflexUser) ToSqlserverflexUserOutputWithContext(ctx context.Context) SqlserverflexUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexUserOutput) +} + +// SqlserverflexUserArrayInput is an input type that accepts SqlserverflexUserArray and SqlserverflexUserArrayOutput values. +// You can construct a concrete instance of `SqlserverflexUserArrayInput` via: +// +// SqlserverflexUserArray{ SqlserverflexUserArgs{...} } +type SqlserverflexUserArrayInput interface { + pulumi.Input + + ToSqlserverflexUserArrayOutput() SqlserverflexUserArrayOutput + ToSqlserverflexUserArrayOutputWithContext(context.Context) SqlserverflexUserArrayOutput +} + +type SqlserverflexUserArray []SqlserverflexUserInput + +func (SqlserverflexUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SqlserverflexUser)(nil)).Elem() +} + +func (i SqlserverflexUserArray) ToSqlserverflexUserArrayOutput() SqlserverflexUserArrayOutput { + return i.ToSqlserverflexUserArrayOutputWithContext(context.Background()) +} + +func (i SqlserverflexUserArray) ToSqlserverflexUserArrayOutputWithContext(ctx context.Context) SqlserverflexUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexUserArrayOutput) +} + +// SqlserverflexUserMapInput is an input type that accepts SqlserverflexUserMap and SqlserverflexUserMapOutput values. +// You can construct a concrete instance of `SqlserverflexUserMapInput` via: +// +// SqlserverflexUserMap{ "key": SqlserverflexUserArgs{...} } +type SqlserverflexUserMapInput interface { + pulumi.Input + + ToSqlserverflexUserMapOutput() SqlserverflexUserMapOutput + ToSqlserverflexUserMapOutputWithContext(context.Context) SqlserverflexUserMapOutput +} + +type SqlserverflexUserMap map[string]SqlserverflexUserInput + +func (SqlserverflexUserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SqlserverflexUser)(nil)).Elem() +} + +func (i SqlserverflexUserMap) ToSqlserverflexUserMapOutput() SqlserverflexUserMapOutput { + return i.ToSqlserverflexUserMapOutputWithContext(context.Background()) +} + +func (i SqlserverflexUserMap) ToSqlserverflexUserMapOutputWithContext(ctx context.Context) SqlserverflexUserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(SqlserverflexUserMapOutput) +} + +type SqlserverflexUserOutput struct{ *pulumi.OutputState } + +func (SqlserverflexUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**SqlserverflexUser)(nil)).Elem() +} + +func (o SqlserverflexUserOutput) ToSqlserverflexUserOutput() SqlserverflexUserOutput { + return o +} + +func (o SqlserverflexUserOutput) ToSqlserverflexUserOutputWithContext(ctx context.Context) SqlserverflexUserOutput { + return o +} + +func (o SqlserverflexUserOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.Host }).(pulumi.StringOutput) +} + +// ID of the SQLServer Flex instance. +func (o SqlserverflexUserOutput) InstanceId() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.InstanceId }).(pulumi.StringOutput) +} + +// Password of the user account. +func (o SqlserverflexUserOutput) Password() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.Password }).(pulumi.StringOutput) +} + +func (o SqlserverflexUserOutput) Port() pulumi.IntOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.IntOutput { return v.Port }).(pulumi.IntOutput) +} + +// STACKIT project ID to which the instance is associated. +func (o SqlserverflexUserOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +func (o SqlserverflexUserOutput) Region() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput) +} + +// Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` +func (o SqlserverflexUserOutput) Roles() pulumi.StringArrayOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringArrayOutput { return v.Roles }).(pulumi.StringArrayOutput) +} + +// User ID. +func (o SqlserverflexUserOutput) UserId() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.UserId }).(pulumi.StringOutput) +} + +// Username of the SQLServer Flex instance. +func (o SqlserverflexUserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *SqlserverflexUser) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type SqlserverflexUserArrayOutput struct{ *pulumi.OutputState } + +func (SqlserverflexUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*SqlserverflexUser)(nil)).Elem() +} + +func (o SqlserverflexUserArrayOutput) ToSqlserverflexUserArrayOutput() SqlserverflexUserArrayOutput { + return o +} + +func (o SqlserverflexUserArrayOutput) ToSqlserverflexUserArrayOutputWithContext(ctx context.Context) SqlserverflexUserArrayOutput { + return o +} + +func (o SqlserverflexUserArrayOutput) Index(i pulumi.IntInput) SqlserverflexUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *SqlserverflexUser { + return vs[0].([]*SqlserverflexUser)[vs[1].(int)] + }).(SqlserverflexUserOutput) +} + +type SqlserverflexUserMapOutput struct{ *pulumi.OutputState } + +func (SqlserverflexUserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*SqlserverflexUser)(nil)).Elem() +} + +func (o SqlserverflexUserMapOutput) ToSqlserverflexUserMapOutput() SqlserverflexUserMapOutput { + return o +} + +func (o SqlserverflexUserMapOutput) ToSqlserverflexUserMapOutputWithContext(ctx context.Context) SqlserverflexUserMapOutput { + return o +} + +func (o SqlserverflexUserMapOutput) MapIndex(k pulumi.StringInput) SqlserverflexUserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *SqlserverflexUser { + return vs[0].(map[string]*SqlserverflexUser)[vs[1].(string)] + }).(SqlserverflexUserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexUserInput)(nil)).Elem(), &SqlserverflexUser{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexUserArrayInput)(nil)).Elem(), SqlserverflexUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*SqlserverflexUserMapInput)(nil)).Elem(), SqlserverflexUserMap{}) + pulumi.RegisterOutputType(SqlserverflexUserOutput{}) + pulumi.RegisterOutputType(SqlserverflexUserArrayOutput{}) + pulumi.RegisterOutputType(SqlserverflexUserMapOutput{}) +} diff --git a/sdk/go/stackit/volume.go b/sdk/go/stackit/volume.go new file mode 100644 index 0000000..f1cc7df --- /dev/null +++ b/sdk/go/stackit/volume.go @@ -0,0 +1,351 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package stackit + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/stackitcloud/pulumi-stackit/sdk/go/stackit/internal" +) + +// Volume resource schema. Must have a `region` specified in the provider configuration. +// +// ## Example Usage +type Volume struct { + pulumi.CustomResourceState + + // The availability zone of the volume. + AvailabilityZone pulumi.StringOutput `pulumi:"availabilityZone"` + // The description of the volume. + Description pulumi.StringOutput `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapOutput `pulumi:"labels"` + // The name of the volume. + Name pulumi.StringOutput `pulumi:"name"` + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass pulumi.StringOutput `pulumi:"performanceClass"` + // STACKIT project ID to which the volume is associated. + ProjectId pulumi.StringOutput `pulumi:"projectId"` + // The server ID of the server to which the volume is attached to. + ServerId pulumi.StringOutput `pulumi:"serverId"` + // The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + Size pulumi.IntOutput `pulumi:"size"` + // The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + Source VolumeSourcePtrOutput `pulumi:"source"` + // The volume ID. + VolumeId pulumi.StringOutput `pulumi:"volumeId"` +} + +// NewVolume registers a new resource with the given unique name, arguments, and options. +func NewVolume(ctx *pulumi.Context, + name string, args *VolumeArgs, opts ...pulumi.ResourceOption) (*Volume, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.AvailabilityZone == nil { + return nil, errors.New("invalid value for required argument 'AvailabilityZone'") + } + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Volume + err := ctx.RegisterResource("stackit:index/volume:Volume", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetVolume gets an existing Volume 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 GetVolume(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *VolumeState, opts ...pulumi.ResourceOption) (*Volume, error) { + var resource Volume + err := ctx.ReadResource("stackit:index/volume:Volume", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Volume resources. +type volumeState struct { + // The availability zone of the volume. + AvailabilityZone *string `pulumi:"availabilityZone"` + // The description of the volume. + Description *string `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the volume. + Name *string `pulumi:"name"` + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass *string `pulumi:"performanceClass"` + // STACKIT project ID to which the volume is associated. + ProjectId *string `pulumi:"projectId"` + // The server ID of the server to which the volume is attached to. + ServerId *string `pulumi:"serverId"` + // The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + Size *int `pulumi:"size"` + // The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + Source *VolumeSource `pulumi:"source"` + // The volume ID. + VolumeId *string `pulumi:"volumeId"` +} + +type VolumeState struct { + // The availability zone of the volume. + AvailabilityZone pulumi.StringPtrInput + // The description of the volume. + Description pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the volume. + Name pulumi.StringPtrInput + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass pulumi.StringPtrInput + // STACKIT project ID to which the volume is associated. + ProjectId pulumi.StringPtrInput + // The server ID of the server to which the volume is attached to. + ServerId pulumi.StringPtrInput + // The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + Size pulumi.IntPtrInput + // The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + Source VolumeSourcePtrInput + // The volume ID. + VolumeId pulumi.StringPtrInput +} + +func (VolumeState) ElementType() reflect.Type { + return reflect.TypeOf((*volumeState)(nil)).Elem() +} + +type volumeArgs struct { + // The availability zone of the volume. + AvailabilityZone string `pulumi:"availabilityZone"` + // The description of the volume. + Description *string `pulumi:"description"` + // Labels are key-value string pairs which can be attached to a resource container + Labels map[string]string `pulumi:"labels"` + // The name of the volume. + Name *string `pulumi:"name"` + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass *string `pulumi:"performanceClass"` + // STACKIT project ID to which the volume is associated. + ProjectId string `pulumi:"projectId"` + // The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + Size *int `pulumi:"size"` + // The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + Source *VolumeSource `pulumi:"source"` +} + +// The set of arguments for constructing a Volume resource. +type VolumeArgs struct { + // The availability zone of the volume. + AvailabilityZone pulumi.StringInput + // The description of the volume. + Description pulumi.StringPtrInput + // Labels are key-value string pairs which can be attached to a resource container + Labels pulumi.StringMapInput + // The name of the volume. + Name pulumi.StringPtrInput + // The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + PerformanceClass pulumi.StringPtrInput + // STACKIT project ID to which the volume is associated. + ProjectId pulumi.StringInput + // The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + Size pulumi.IntPtrInput + // The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + Source VolumeSourcePtrInput +} + +func (VolumeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*volumeArgs)(nil)).Elem() +} + +type VolumeInput interface { + pulumi.Input + + ToVolumeOutput() VolumeOutput + ToVolumeOutputWithContext(ctx context.Context) VolumeOutput +} + +func (*Volume) ElementType() reflect.Type { + return reflect.TypeOf((**Volume)(nil)).Elem() +} + +func (i *Volume) ToVolumeOutput() VolumeOutput { + return i.ToVolumeOutputWithContext(context.Background()) +} + +func (i *Volume) ToVolumeOutputWithContext(ctx context.Context) VolumeOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeOutput) +} + +// VolumeArrayInput is an input type that accepts VolumeArray and VolumeArrayOutput values. +// You can construct a concrete instance of `VolumeArrayInput` via: +// +// VolumeArray{ VolumeArgs{...} } +type VolumeArrayInput interface { + pulumi.Input + + ToVolumeArrayOutput() VolumeArrayOutput + ToVolumeArrayOutputWithContext(context.Context) VolumeArrayOutput +} + +type VolumeArray []VolumeInput + +func (VolumeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Volume)(nil)).Elem() +} + +func (i VolumeArray) ToVolumeArrayOutput() VolumeArrayOutput { + return i.ToVolumeArrayOutputWithContext(context.Background()) +} + +func (i VolumeArray) ToVolumeArrayOutputWithContext(ctx context.Context) VolumeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeArrayOutput) +} + +// VolumeMapInput is an input type that accepts VolumeMap and VolumeMapOutput values. +// You can construct a concrete instance of `VolumeMapInput` via: +// +// VolumeMap{ "key": VolumeArgs{...} } +type VolumeMapInput interface { + pulumi.Input + + ToVolumeMapOutput() VolumeMapOutput + ToVolumeMapOutputWithContext(context.Context) VolumeMapOutput +} + +type VolumeMap map[string]VolumeInput + +func (VolumeMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Volume)(nil)).Elem() +} + +func (i VolumeMap) ToVolumeMapOutput() VolumeMapOutput { + return i.ToVolumeMapOutputWithContext(context.Background()) +} + +func (i VolumeMap) ToVolumeMapOutputWithContext(ctx context.Context) VolumeMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(VolumeMapOutput) +} + +type VolumeOutput struct{ *pulumi.OutputState } + +func (VolumeOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Volume)(nil)).Elem() +} + +func (o VolumeOutput) ToVolumeOutput() VolumeOutput { + return o +} + +func (o VolumeOutput) ToVolumeOutputWithContext(ctx context.Context) VolumeOutput { + return o +} + +// The availability zone of the volume. +func (o VolumeOutput) AvailabilityZone() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.AvailabilityZone }).(pulumi.StringOutput) +} + +// The description of the volume. +func (o VolumeOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput) +} + +// Labels are key-value string pairs which can be attached to a resource container +func (o VolumeOutput) Labels() pulumi.StringMapOutput { + return o.ApplyT(func(v *Volume) pulumi.StringMapOutput { return v.Labels }).(pulumi.StringMapOutput) +} + +// The name of the volume. +func (o VolumeOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) +func (o VolumeOutput) PerformanceClass() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.PerformanceClass }).(pulumi.StringOutput) +} + +// STACKIT project ID to which the volume is associated. +func (o VolumeOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +// The server ID of the server to which the volume is attached to. +func (o VolumeOutput) ServerId() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.ServerId }).(pulumi.StringOutput) +} + +// The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided +func (o VolumeOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v *Volume) pulumi.IntOutput { return v.Size }).(pulumi.IntOutput) +} + +// The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided +func (o VolumeOutput) Source() VolumeSourcePtrOutput { + return o.ApplyT(func(v *Volume) VolumeSourcePtrOutput { return v.Source }).(VolumeSourcePtrOutput) +} + +// The volume ID. +func (o VolumeOutput) VolumeId() pulumi.StringOutput { + return o.ApplyT(func(v *Volume) pulumi.StringOutput { return v.VolumeId }).(pulumi.StringOutput) +} + +type VolumeArrayOutput struct{ *pulumi.OutputState } + +func (VolumeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Volume)(nil)).Elem() +} + +func (o VolumeArrayOutput) ToVolumeArrayOutput() VolumeArrayOutput { + return o +} + +func (o VolumeArrayOutput) ToVolumeArrayOutputWithContext(ctx context.Context) VolumeArrayOutput { + return o +} + +func (o VolumeArrayOutput) Index(i pulumi.IntInput) VolumeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Volume { + return vs[0].([]*Volume)[vs[1].(int)] + }).(VolumeOutput) +} + +type VolumeMapOutput struct{ *pulumi.OutputState } + +func (VolumeMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Volume)(nil)).Elem() +} + +func (o VolumeMapOutput) ToVolumeMapOutput() VolumeMapOutput { + return o +} + +func (o VolumeMapOutput) ToVolumeMapOutputWithContext(ctx context.Context) VolumeMapOutput { + return o +} + +func (o VolumeMapOutput) MapIndex(k pulumi.StringInput) VolumeOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Volume { + return vs[0].(map[string]*Volume)[vs[1].(string)] + }).(VolumeOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*VolumeInput)(nil)).Elem(), &Volume{}) + pulumi.RegisterInputType(reflect.TypeOf((*VolumeArrayInput)(nil)).Elem(), VolumeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*VolumeMapInput)(nil)).Elem(), VolumeMap{}) + pulumi.RegisterOutputType(VolumeOutput{}) + pulumi.RegisterOutputType(VolumeArrayOutput{}) + pulumi.RegisterOutputType(VolumeMapOutput{}) +} diff --git a/sdk/nodejs/Pulumi.yaml b/sdk/nodejs/Pulumi.yaml new file mode 100644 index 0000000..e69de29 diff --git a/sdk/nodejs/README.md b/sdk/nodejs/README.md new file mode 100644 index 0000000..fef1af7 --- /dev/null +++ b/sdk/nodejs/README.md @@ -0,0 +1,4 @@ +> This provider is a derived work of the [Terraform Provider](https://github.com/stackitcloud/terraform-provider-stackit) +> distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature, +> first check the [`pulumi-stackit` repo](https://github.com/stackitcloud/pulumi-stackit/issues); however, if that doesn't turn up anything, +> please consult the source [`terraform-provider-stackit` repo](https://github.com/stackitcloud/terraform-provider-stackit/issues). diff --git a/sdk/nodejs/affinityGroup.ts b/sdk/nodejs/affinityGroup.ts new file mode 100644 index 0000000..ad9f02c --- /dev/null +++ b/sdk/nodejs/affinityGroup.ts @@ -0,0 +1,140 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Affinity Group schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class AffinityGroup extends pulumi.CustomResource { + /** + * Get an existing AffinityGroup 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?: AffinityGroupState, opts?: pulumi.CustomResourceOptions): AffinityGroup { + return new AffinityGroup(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/affinityGroup:AffinityGroup'; + + /** + * Returns true if the given object is an instance of AffinityGroup. 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 AffinityGroup { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === AffinityGroup.__pulumiType; + } + + /** + * The affinity group ID. + */ + public /*out*/ readonly affinityGroupId!: pulumi.Output; + /** + * The servers that are part of the affinity group. + */ + public /*out*/ readonly members!: pulumi.Output; + /** + * The name of the affinity group. + */ + public readonly name!: pulumi.Output; + /** + * The policy of the affinity group. + */ + public readonly policy!: pulumi.Output; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + public readonly projectId!: pulumi.Output; + + /** + * Create a AffinityGroup 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: AffinityGroupArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: AffinityGroupArgs | AffinityGroupState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as AffinityGroupState | undefined; + resourceInputs["affinityGroupId"] = state ? state.affinityGroupId : undefined; + resourceInputs["members"] = state ? state.members : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["policy"] = state ? state.policy : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + } else { + const args = argsOrState as AffinityGroupArgs | undefined; + if ((!args || args.policy === undefined) && !opts.urn) { + throw new Error("Missing required property 'policy'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["policy"] = args ? args.policy : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["affinityGroupId"] = undefined /*out*/; + resourceInputs["members"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(AffinityGroup.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering AffinityGroup resources. + */ +export interface AffinityGroupState { + /** + * The affinity group ID. + */ + affinityGroupId?: pulumi.Input; + /** + * The servers that are part of the affinity group. + */ + members?: pulumi.Input[]>; + /** + * The name of the affinity group. + */ + name?: pulumi.Input; + /** + * The policy of the affinity group. + */ + policy?: pulumi.Input; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + projectId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a AffinityGroup resource. + */ +export interface AffinityGroupArgs { + /** + * The name of the affinity group. + */ + name?: pulumi.Input; + /** + * The policy of the affinity group. + */ + policy: pulumi.Input; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/authorizationOrganizationRoleAssignment.ts b/sdk/nodejs/authorizationOrganizationRoleAssignment.ts new file mode 100644 index 0000000..8ab7579 --- /dev/null +++ b/sdk/nodejs/authorizationOrganizationRoleAssignment.ts @@ -0,0 +1,125 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * organization Role Assignment resource schema. + * + * > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + * + * ## Example Usage + */ +export class AuthorizationOrganizationRoleAssignment extends pulumi.CustomResource { + /** + * Get an existing AuthorizationOrganizationRoleAssignment 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?: AuthorizationOrganizationRoleAssignmentState, opts?: pulumi.CustomResourceOptions): AuthorizationOrganizationRoleAssignment { + return new AuthorizationOrganizationRoleAssignment(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment'; + + /** + * Returns true if the given object is an instance of AuthorizationOrganizationRoleAssignment. 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 AuthorizationOrganizationRoleAssignment { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === AuthorizationOrganizationRoleAssignment.__pulumiType; + } + + /** + * organization Resource to assign the role to. + */ + public readonly resourceId!: pulumi.Output; + /** + * Role to be assigned + */ + public readonly role!: pulumi.Output; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + public readonly subject!: pulumi.Output; + + /** + * Create a AuthorizationOrganizationRoleAssignment 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: AuthorizationOrganizationRoleAssignmentArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: AuthorizationOrganizationRoleAssignmentArgs | AuthorizationOrganizationRoleAssignmentState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as AuthorizationOrganizationRoleAssignmentState | undefined; + resourceInputs["resourceId"] = state ? state.resourceId : undefined; + resourceInputs["role"] = state ? state.role : undefined; + resourceInputs["subject"] = state ? state.subject : undefined; + } else { + const args = argsOrState as AuthorizationOrganizationRoleAssignmentArgs | undefined; + if ((!args || args.resourceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'resourceId'"); + } + if ((!args || args.role === undefined) && !opts.urn) { + throw new Error("Missing required property 'role'"); + } + if ((!args || args.subject === undefined) && !opts.urn) { + throw new Error("Missing required property 'subject'"); + } + resourceInputs["resourceId"] = args ? args.resourceId : undefined; + resourceInputs["role"] = args ? args.role : undefined; + resourceInputs["subject"] = args ? args.subject : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(AuthorizationOrganizationRoleAssignment.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering AuthorizationOrganizationRoleAssignment resources. + */ +export interface AuthorizationOrganizationRoleAssignmentState { + /** + * organization Resource to assign the role to. + */ + resourceId?: pulumi.Input; + /** + * Role to be assigned + */ + role?: pulumi.Input; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + subject?: pulumi.Input; +} + +/** + * The set of arguments for constructing a AuthorizationOrganizationRoleAssignment resource. + */ +export interface AuthorizationOrganizationRoleAssignmentArgs { + /** + * organization Resource to assign the role to. + */ + resourceId: pulumi.Input; + /** + * Role to be assigned + */ + role: pulumi.Input; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + subject: pulumi.Input; +} diff --git a/sdk/nodejs/authorizationProjectRoleAssignment.ts b/sdk/nodejs/authorizationProjectRoleAssignment.ts new file mode 100644 index 0000000..67ac550 --- /dev/null +++ b/sdk/nodejs/authorizationProjectRoleAssignment.ts @@ -0,0 +1,125 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * project Role Assignment resource schema. + * + * > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + * + * ## Example Usage + */ +export class AuthorizationProjectRoleAssignment extends pulumi.CustomResource { + /** + * Get an existing AuthorizationProjectRoleAssignment 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?: AuthorizationProjectRoleAssignmentState, opts?: pulumi.CustomResourceOptions): AuthorizationProjectRoleAssignment { + return new AuthorizationProjectRoleAssignment(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment'; + + /** + * Returns true if the given object is an instance of AuthorizationProjectRoleAssignment. 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 AuthorizationProjectRoleAssignment { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === AuthorizationProjectRoleAssignment.__pulumiType; + } + + /** + * project Resource to assign the role to. + */ + public readonly resourceId!: pulumi.Output; + /** + * Role to be assigned + */ + public readonly role!: pulumi.Output; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + public readonly subject!: pulumi.Output; + + /** + * Create a AuthorizationProjectRoleAssignment 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: AuthorizationProjectRoleAssignmentArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: AuthorizationProjectRoleAssignmentArgs | AuthorizationProjectRoleAssignmentState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as AuthorizationProjectRoleAssignmentState | undefined; + resourceInputs["resourceId"] = state ? state.resourceId : undefined; + resourceInputs["role"] = state ? state.role : undefined; + resourceInputs["subject"] = state ? state.subject : undefined; + } else { + const args = argsOrState as AuthorizationProjectRoleAssignmentArgs | undefined; + if ((!args || args.resourceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'resourceId'"); + } + if ((!args || args.role === undefined) && !opts.urn) { + throw new Error("Missing required property 'role'"); + } + if ((!args || args.subject === undefined) && !opts.urn) { + throw new Error("Missing required property 'subject'"); + } + resourceInputs["resourceId"] = args ? args.resourceId : undefined; + resourceInputs["role"] = args ? args.role : undefined; + resourceInputs["subject"] = args ? args.subject : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(AuthorizationProjectRoleAssignment.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering AuthorizationProjectRoleAssignment resources. + */ +export interface AuthorizationProjectRoleAssignmentState { + /** + * project Resource to assign the role to. + */ + resourceId?: pulumi.Input; + /** + * Role to be assigned + */ + role?: pulumi.Input; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + subject?: pulumi.Input; +} + +/** + * The set of arguments for constructing a AuthorizationProjectRoleAssignment resource. + */ +export interface AuthorizationProjectRoleAssignmentArgs { + /** + * project Resource to assign the role to. + */ + resourceId: pulumi.Input; + /** + * Role to be assigned + */ + role: pulumi.Input; + /** + * Identifier of user, service account or client. Usually email address or name in case of clients + */ + subject: pulumi.Input; +} diff --git a/sdk/nodejs/cdnCustomDomain.ts b/sdk/nodejs/cdnCustomDomain.ts new file mode 100644 index 0000000..21e6c8e --- /dev/null +++ b/sdk/nodejs/cdnCustomDomain.ts @@ -0,0 +1,133 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export class CdnCustomDomain extends pulumi.CustomResource { + /** + * Get an existing CdnCustomDomain 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?: CdnCustomDomainState, opts?: pulumi.CustomResourceOptions): CdnCustomDomain { + return new CdnCustomDomain(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/cdnCustomDomain:CdnCustomDomain'; + + /** + * Returns true if the given object is an instance of CdnCustomDomain. 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 CdnCustomDomain { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === CdnCustomDomain.__pulumiType; + } + + /** + * CDN distribution ID + */ + public readonly distributionId!: pulumi.Output; + /** + * List of distribution errors + */ + public /*out*/ readonly errors!: pulumi.Output; + public readonly name!: pulumi.Output; + /** + * STACKIT project ID associated with the distribution + */ + public readonly projectId!: pulumi.Output; + /** + * Status of the distribution + */ + public /*out*/ readonly status!: pulumi.Output; + + /** + * Create a CdnCustomDomain 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: CdnCustomDomainArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: CdnCustomDomainArgs | CdnCustomDomainState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as CdnCustomDomainState | undefined; + resourceInputs["distributionId"] = state ? state.distributionId : undefined; + resourceInputs["errors"] = state ? state.errors : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["status"] = state ? state.status : undefined; + } else { + const args = argsOrState as CdnCustomDomainArgs | undefined; + if ((!args || args.distributionId === undefined) && !opts.urn) { + throw new Error("Missing required property 'distributionId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["distributionId"] = args ? args.distributionId : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["errors"] = undefined /*out*/; + resourceInputs["status"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(CdnCustomDomain.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering CdnCustomDomain resources. + */ +export interface CdnCustomDomainState { + /** + * CDN distribution ID + */ + distributionId?: pulumi.Input; + /** + * List of distribution errors + */ + errors?: pulumi.Input[]>; + name?: pulumi.Input; + /** + * STACKIT project ID associated with the distribution + */ + projectId?: pulumi.Input; + /** + * Status of the distribution + */ + status?: pulumi.Input; +} + +/** + * The set of arguments for constructing a CdnCustomDomain resource. + */ +export interface CdnCustomDomainArgs { + /** + * CDN distribution ID + */ + distributionId: pulumi.Input; + name?: pulumi.Input; + /** + * STACKIT project ID associated with the distribution + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/cdnDistribution.ts b/sdk/nodejs/cdnDistribution.ts new file mode 100644 index 0000000..6ec7885 --- /dev/null +++ b/sdk/nodejs/cdnDistribution.ts @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export class CdnDistribution extends pulumi.CustomResource { + /** + * Get an existing CdnDistribution 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?: CdnDistributionState, opts?: pulumi.CustomResourceOptions): CdnDistribution { + return new CdnDistribution(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/cdnDistribution:CdnDistribution'; + + /** + * Returns true if the given object is an instance of CdnDistribution. 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 CdnDistribution { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === CdnDistribution.__pulumiType; + } + + /** + * The distribution configuration + */ + public readonly config!: pulumi.Output; + /** + * Time when the distribution was created + */ + public /*out*/ readonly createdAt!: pulumi.Output; + /** + * CDN distribution ID + */ + public /*out*/ readonly distributionId!: pulumi.Output; + /** + * List of configured domains for the distribution + */ + public /*out*/ readonly domains!: pulumi.Output; + /** + * List of distribution errors + */ + public /*out*/ readonly errors!: pulumi.Output; + /** + * STACKIT project ID associated with the distribution + */ + public readonly projectId!: pulumi.Output; + /** + * Status of the distribution + */ + public /*out*/ readonly status!: pulumi.Output; + /** + * Time when the distribution was last updated + */ + public /*out*/ readonly updatedAt!: pulumi.Output; + + /** + * Create a CdnDistribution 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: CdnDistributionArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: CdnDistributionArgs | CdnDistributionState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as CdnDistributionState | undefined; + resourceInputs["config"] = state ? state.config : undefined; + resourceInputs["createdAt"] = state ? state.createdAt : undefined; + resourceInputs["distributionId"] = state ? state.distributionId : undefined; + resourceInputs["domains"] = state ? state.domains : undefined; + resourceInputs["errors"] = state ? state.errors : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["status"] = state ? state.status : undefined; + resourceInputs["updatedAt"] = state ? state.updatedAt : undefined; + } else { + const args = argsOrState as CdnDistributionArgs | undefined; + if ((!args || args.config === undefined) && !opts.urn) { + throw new Error("Missing required property 'config'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["config"] = args ? args.config : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["createdAt"] = undefined /*out*/; + resourceInputs["distributionId"] = undefined /*out*/; + resourceInputs["domains"] = undefined /*out*/; + resourceInputs["errors"] = undefined /*out*/; + resourceInputs["status"] = undefined /*out*/; + resourceInputs["updatedAt"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(CdnDistribution.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering CdnDistribution resources. + */ +export interface CdnDistributionState { + /** + * The distribution configuration + */ + config?: pulumi.Input; + /** + * Time when the distribution was created + */ + createdAt?: pulumi.Input; + /** + * CDN distribution ID + */ + distributionId?: pulumi.Input; + /** + * List of configured domains for the distribution + */ + domains?: pulumi.Input[]>; + /** + * List of distribution errors + */ + errors?: pulumi.Input[]>; + /** + * STACKIT project ID associated with the distribution + */ + projectId?: pulumi.Input; + /** + * Status of the distribution + */ + status?: pulumi.Input; + /** + * Time when the distribution was last updated + */ + updatedAt?: pulumi.Input; +} + +/** + * The set of arguments for constructing a CdnDistribution resource. + */ +export interface CdnDistributionArgs { + /** + * The distribution configuration + */ + config: pulumi.Input; + /** + * STACKIT project ID associated with the distribution + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/config/index.ts b/sdk/nodejs/config/index.ts new file mode 100644 index 0000000..3fbadc8 --- /dev/null +++ b/sdk/nodejs/config/index.ts @@ -0,0 +1,5 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +// Export members: +export * from "./vars"; diff --git a/sdk/nodejs/config/vars.ts b/sdk/nodejs/config/vars.ts new file mode 100644 index 0000000..5409fd8 --- /dev/null +++ b/sdk/nodejs/config/vars.ts @@ -0,0 +1,422 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +declare var exports: any; +const __config = new pulumi.Config("stackit"); + +/** + * Custom endpoint for the Argus service + */ +export declare const argusCustomEndpoint: string | undefined; +Object.defineProperty(exports, "argusCustomEndpoint", { + get() { + return __config.get("argusCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Membership service + */ +export declare const authorizationCustomEndpoint: string | undefined; +Object.defineProperty(exports, "authorizationCustomEndpoint", { + get() { + return __config.get("authorizationCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the CDN service + */ +export declare const cdnCustomEndpoint: string | undefined; +Object.defineProperty(exports, "cdnCustomEndpoint", { + get() { + return __config.get("cdnCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + * value is `~/.stackit/credentials.json`. + */ +export declare const credentialsPath: string | undefined; +Object.defineProperty(exports, "credentialsPath", { + get() { + return __config.get("credentialsPath"); + }, + enumerable: true, +}); + +/** + * Region will be used as the default location for regional services. Not all services require a region, some are global + */ +export declare const defaultRegion: string | undefined; +Object.defineProperty(exports, "defaultRegion", { + get() { + return __config.get("defaultRegion"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the DNS service + */ +export declare const dnsCustomEndpoint: string | undefined; +Object.defineProperty(exports, "dnsCustomEndpoint", { + get() { + return __config.get("dnsCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Enable beta resources. Default is false. + */ +export declare const enableBetaResources: boolean | undefined; +Object.defineProperty(exports, "enableBetaResources", { + get() { + return __config.getObject("enableBetaResources"); + }, + enumerable: true, +}); + +/** + * Enables experiments. These are unstable features without official support. More information can be found in the README. + * Available Experiments: [iam] + */ +export declare const experiments: string[] | undefined; +Object.defineProperty(exports, "experiments", { + get() { + return __config.getObject("experiments"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Git service + */ +export declare const gitCustomEndpoint: string | undefined; +Object.defineProperty(exports, "gitCustomEndpoint", { + get() { + return __config.get("gitCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the IaaS service + */ +export declare const iaasCustomEndpoint: string | undefined; +Object.defineProperty(exports, "iaasCustomEndpoint", { + get() { + return __config.get("iaasCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Load Balancer service + */ +export declare const loadbalancerCustomEndpoint: string | undefined; +Object.defineProperty(exports, "loadbalancerCustomEndpoint", { + get() { + return __config.get("loadbalancerCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the LogMe service + */ +export declare const logmeCustomEndpoint: string | undefined; +Object.defineProperty(exports, "logmeCustomEndpoint", { + get() { + return __config.get("logmeCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the MariaDB service + */ +export declare const mariadbCustomEndpoint: string | undefined; +Object.defineProperty(exports, "mariadbCustomEndpoint", { + get() { + return __config.get("mariadbCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the AI Model Serving service + */ +export declare const modelservingCustomEndpoint: string | undefined; +Object.defineProperty(exports, "modelservingCustomEndpoint", { + get() { + return __config.get("modelservingCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the MongoDB Flex service + */ +export declare const mongodbflexCustomEndpoint: string | undefined; +Object.defineProperty(exports, "mongodbflexCustomEndpoint", { + get() { + return __config.get("mongodbflexCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Object Storage service + */ +export declare const objectstorageCustomEndpoint: string | undefined; +Object.defineProperty(exports, "objectstorageCustomEndpoint", { + get() { + return __config.get("objectstorageCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Observability service + */ +export declare const observabilityCustomEndpoint: string | undefined; +Object.defineProperty(exports, "observabilityCustomEndpoint", { + get() { + return __config.get("observabilityCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the OpenSearch service + */ +export declare const opensearchCustomEndpoint: string | undefined; +Object.defineProperty(exports, "opensearchCustomEndpoint", { + get() { + return __config.get("opensearchCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the PostgresFlex service + */ +export declare const postgresflexCustomEndpoint: string | undefined; +Object.defineProperty(exports, "postgresflexCustomEndpoint", { + get() { + return __config.get("postgresflexCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + * included in the service account key. + */ +export declare const privateKey: string | undefined; +Object.defineProperty(exports, "privateKey", { + get() { + return __config.get("privateKey"); + }, + enumerable: true, +}); + +/** + * Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + * key that is included in the service account key. + */ +export declare const privateKeyPath: string | undefined; +Object.defineProperty(exports, "privateKeyPath", { + get() { + return __config.get("privateKeyPath"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the RabbitMQ service + */ +export declare const rabbitmqCustomEndpoint: string | undefined; +Object.defineProperty(exports, "rabbitmqCustomEndpoint", { + get() { + return __config.get("rabbitmqCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Redis service + */ +export declare const redisCustomEndpoint: string | undefined; +Object.defineProperty(exports, "redisCustomEndpoint", { + get() { + return __config.get("redisCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Region will be used as the default location for regional services. Not all services require a region, some are global + */ +export declare const region: string | undefined; +Object.defineProperty(exports, "region", { + get() { + return __config.get("region"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Resource Manager service + */ +export declare const resourcemanagerCustomEndpoint: string | undefined; +Object.defineProperty(exports, "resourcemanagerCustomEndpoint", { + get() { + return __config.get("resourcemanagerCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Secrets Manager service + */ +export declare const secretsmanagerCustomEndpoint: string | undefined; +Object.defineProperty(exports, "secretsmanagerCustomEndpoint", { + get() { + return __config.get("secretsmanagerCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Server Backup service + */ +export declare const serverBackupCustomEndpoint: string | undefined; +Object.defineProperty(exports, "serverBackupCustomEndpoint", { + get() { + return __config.get("serverBackupCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Server Update service + */ +export declare const serverUpdateCustomEndpoint: string | undefined; +Object.defineProperty(exports, "serverUpdateCustomEndpoint", { + get() { + return __config.get("serverUpdateCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Service Account service + */ +export declare const serviceAccountCustomEndpoint: string | undefined; +Object.defineProperty(exports, "serviceAccountCustomEndpoint", { + get() { + return __config.get("serviceAccountCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + * if you want to use the resource manager project resource. + */ +export declare const serviceAccountEmail: string | undefined; +Object.defineProperty(exports, "serviceAccountEmail", { + get() { + return __config.get("serviceAccountEmail"); + }, + enumerable: true, +}); + +/** + * Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + */ +export declare const serviceAccountKey: string | undefined; +Object.defineProperty(exports, "serviceAccountKey", { + get() { + return __config.get("serviceAccountKey"); + }, + enumerable: true, +}); + +/** + * Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + * operations. + */ +export declare const serviceAccountKeyPath: string | undefined; +Object.defineProperty(exports, "serviceAccountKeyPath", { + get() { + return __config.get("serviceAccountKeyPath"); + }, + enumerable: true, +}); + +/** + * Token used for authentication. If set, the token flow will be used to authenticate all operations. + */ +export declare const serviceAccountToken: string | undefined; +Object.defineProperty(exports, "serviceAccountToken", { + get() { + return __config.get("serviceAccountToken"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Service Enablement API + */ +export declare const serviceEnablementCustomEndpoint: string | undefined; +Object.defineProperty(exports, "serviceEnablementCustomEndpoint", { + get() { + return __config.get("serviceEnablementCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the Kubernetes Engine (SKE) service + */ +export declare const skeCustomEndpoint: string | undefined; +Object.defineProperty(exports, "skeCustomEndpoint", { + get() { + return __config.get("skeCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the SQL Server Flex service + */ +export declare const sqlserverflexCustomEndpoint: string | undefined; +Object.defineProperty(exports, "sqlserverflexCustomEndpoint", { + get() { + return __config.get("sqlserverflexCustomEndpoint"); + }, + enumerable: true, +}); + +/** + * Custom endpoint for the token API, which is used to request access tokens when using the key flow + */ +export declare const tokenCustomEndpoint: string | undefined; +Object.defineProperty(exports, "tokenCustomEndpoint", { + get() { + return __config.get("tokenCustomEndpoint"); + }, + enumerable: true, +}); + diff --git a/sdk/nodejs/dnsRecordSet.ts b/sdk/nodejs/dnsRecordSet.ts new file mode 100644 index 0000000..5d17074 --- /dev/null +++ b/sdk/nodejs/dnsRecordSet.ts @@ -0,0 +1,236 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * DNS Record Set Resource schema. + * + * ## Example Usage + */ +export class DnsRecordSet extends pulumi.CustomResource { + /** + * Get an existing DnsRecordSet 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?: DnsRecordSetState, opts?: pulumi.CustomResourceOptions): DnsRecordSet { + return new DnsRecordSet(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/dnsRecordSet:DnsRecordSet'; + + /** + * Returns true if the given object is an instance of DnsRecordSet. 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 DnsRecordSet { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === DnsRecordSet.__pulumiType; + } + + /** + * Specifies if the record set is active or not. Defaults to `true` + */ + public readonly active!: pulumi.Output; + /** + * Comment. + */ + public readonly comment!: pulumi.Output; + /** + * Error shows error in case create/update/delete failed. + */ + public /*out*/ readonly error!: pulumi.Output; + /** + * Fully qualified domain name (FQDN) of the record set. + */ + public /*out*/ readonly fqdn!: pulumi.Output; + /** + * Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the dns record set is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The rr set id. + */ + public /*out*/ readonly recordSetId!: pulumi.Output; + /** + * Records. + */ + public readonly records!: pulumi.Output; + /** + * Record set state. + */ + public /*out*/ readonly state!: pulumi.Output; + /** + * Time to live. E.g. 3600 + */ + public readonly ttl!: pulumi.Output; + /** + * The record set type. E.g. `A` or `CNAME` + */ + public readonly type!: pulumi.Output; + /** + * The zone ID to which is dns record set is associated. + */ + public readonly zoneId!: pulumi.Output; + + /** + * Create a DnsRecordSet 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: DnsRecordSetArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: DnsRecordSetArgs | DnsRecordSetState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as DnsRecordSetState | undefined; + resourceInputs["active"] = state ? state.active : undefined; + resourceInputs["comment"] = state ? state.comment : undefined; + resourceInputs["error"] = state ? state.error : undefined; + resourceInputs["fqdn"] = state ? state.fqdn : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["recordSetId"] = state ? state.recordSetId : undefined; + resourceInputs["records"] = state ? state.records : undefined; + resourceInputs["state"] = state ? state.state : undefined; + resourceInputs["ttl"] = state ? state.ttl : undefined; + resourceInputs["type"] = state ? state.type : undefined; + resourceInputs["zoneId"] = state ? state.zoneId : undefined; + } else { + const args = argsOrState as DnsRecordSetArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.records === undefined) && !opts.urn) { + throw new Error("Missing required property 'records'"); + } + if ((!args || args.type === undefined) && !opts.urn) { + throw new Error("Missing required property 'type'"); + } + if ((!args || args.zoneId === undefined) && !opts.urn) { + throw new Error("Missing required property 'zoneId'"); + } + resourceInputs["active"] = args ? args.active : undefined; + resourceInputs["comment"] = args ? args.comment : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["records"] = args ? args.records : undefined; + resourceInputs["ttl"] = args ? args.ttl : undefined; + resourceInputs["type"] = args ? args.type : undefined; + resourceInputs["zoneId"] = args ? args.zoneId : undefined; + resourceInputs["error"] = undefined /*out*/; + resourceInputs["fqdn"] = undefined /*out*/; + resourceInputs["recordSetId"] = undefined /*out*/; + resourceInputs["state"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(DnsRecordSet.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering DnsRecordSet resources. + */ +export interface DnsRecordSetState { + /** + * Specifies if the record set is active or not. Defaults to `true` + */ + active?: pulumi.Input; + /** + * Comment. + */ + comment?: pulumi.Input; + /** + * Error shows error in case create/update/delete failed. + */ + error?: pulumi.Input; + /** + * Fully qualified domain name (FQDN) of the record set. + */ + fqdn?: pulumi.Input; + /** + * Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the dns record set is associated. + */ + projectId?: pulumi.Input; + /** + * The rr set id. + */ + recordSetId?: pulumi.Input; + /** + * Records. + */ + records?: pulumi.Input[]>; + /** + * Record set state. + */ + state?: pulumi.Input; + /** + * Time to live. E.g. 3600 + */ + ttl?: pulumi.Input; + /** + * The record set type. E.g. `A` or `CNAME` + */ + type?: pulumi.Input; + /** + * The zone ID to which is dns record set is associated. + */ + zoneId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a DnsRecordSet resource. + */ +export interface DnsRecordSetArgs { + /** + * Specifies if the record set is active or not. Defaults to `true` + */ + active?: pulumi.Input; + /** + * Comment. + */ + comment?: pulumi.Input; + /** + * Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the dns record set is associated. + */ + projectId: pulumi.Input; + /** + * Records. + */ + records: pulumi.Input[]>; + /** + * Time to live. E.g. 3600 + */ + ttl?: pulumi.Input; + /** + * The record set type. E.g. `A` or `CNAME` + */ + type: pulumi.Input; + /** + * The zone ID to which is dns record set is associated. + */ + zoneId: pulumi.Input; +} diff --git a/sdk/nodejs/dnsZone.ts b/sdk/nodejs/dnsZone.ts new file mode 100644 index 0000000..c63ed92 --- /dev/null +++ b/sdk/nodejs/dnsZone.ts @@ -0,0 +1,339 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * DNS Zone resource schema. + * + * ## Example Usage + */ +export class DnsZone extends pulumi.CustomResource { + /** + * Get an existing DnsZone 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?: DnsZoneState, opts?: pulumi.CustomResourceOptions): DnsZone { + return new DnsZone(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/dnsZone:DnsZone'; + + /** + * Returns true if the given object is an instance of DnsZone. 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 DnsZone { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === DnsZone.__pulumiType; + } + + /** + * The access control list. E.g. `0.0.0.0/0,::/0` + */ + public readonly acl!: pulumi.Output; + public readonly active!: pulumi.Output; + /** + * A contact e-mail for the zone. + */ + public readonly contactEmail!: pulumi.Output; + /** + * Default time to live. E.g. 3600. + */ + public readonly defaultTtl!: pulumi.Output; + /** + * Description of the zone. + */ + public readonly description!: pulumi.Output; + /** + * The zone name. E.g. `example.com` + */ + public readonly dnsName!: pulumi.Output; + /** + * Expire time. E.g. 1209600. + */ + public readonly expireTime!: pulumi.Output; + /** + * Specifies, if the zone is a reverse zone or not. Defaults to `false` + */ + public readonly isReverseZone!: pulumi.Output; + /** + * The user given name of the zone. + */ + public readonly name!: pulumi.Output; + /** + * Negative caching. E.g. 60 + */ + public readonly negativeCache!: pulumi.Output; + /** + * Primary name server for secondary zone. E.g. ["1.2.3.4"] + */ + public readonly primaries!: pulumi.Output; + /** + * Primary name server. FQDN. + */ + public /*out*/ readonly primaryNameServer!: pulumi.Output; + /** + * STACKIT project ID to which the dns zone is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Record count how many records are in the zone. + */ + public /*out*/ readonly recordCount!: pulumi.Output; + /** + * Refresh time. E.g. 3600 + */ + public readonly refreshTime!: pulumi.Output; + /** + * Retry time. E.g. 600 + */ + public readonly retryTime!: pulumi.Output; + /** + * Serial number. E.g. `2022111400`. + */ + public /*out*/ readonly serialNumber!: pulumi.Output; + /** + * Zone state. E.g. `CREATE_SUCCEEDED`. + */ + public /*out*/ readonly state!: pulumi.Output; + /** + * Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + */ + public readonly type!: pulumi.Output; + /** + * Visibility of the zone. E.g. `public`. + */ + public /*out*/ readonly visibility!: pulumi.Output; + /** + * The zone ID. + */ + public /*out*/ readonly zoneId!: pulumi.Output; + + /** + * Create a DnsZone 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: DnsZoneArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: DnsZoneArgs | DnsZoneState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as DnsZoneState | undefined; + resourceInputs["acl"] = state ? state.acl : undefined; + resourceInputs["active"] = state ? state.active : undefined; + resourceInputs["contactEmail"] = state ? state.contactEmail : undefined; + resourceInputs["defaultTtl"] = state ? state.defaultTtl : undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["dnsName"] = state ? state.dnsName : undefined; + resourceInputs["expireTime"] = state ? state.expireTime : undefined; + resourceInputs["isReverseZone"] = state ? state.isReverseZone : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["negativeCache"] = state ? state.negativeCache : undefined; + resourceInputs["primaries"] = state ? state.primaries : undefined; + resourceInputs["primaryNameServer"] = state ? state.primaryNameServer : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["recordCount"] = state ? state.recordCount : undefined; + resourceInputs["refreshTime"] = state ? state.refreshTime : undefined; + resourceInputs["retryTime"] = state ? state.retryTime : undefined; + resourceInputs["serialNumber"] = state ? state.serialNumber : undefined; + resourceInputs["state"] = state ? state.state : undefined; + resourceInputs["type"] = state ? state.type : undefined; + resourceInputs["visibility"] = state ? state.visibility : undefined; + resourceInputs["zoneId"] = state ? state.zoneId : undefined; + } else { + const args = argsOrState as DnsZoneArgs | undefined; + if ((!args || args.dnsName === undefined) && !opts.urn) { + throw new Error("Missing required property 'dnsName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["acl"] = args ? args.acl : undefined; + resourceInputs["active"] = args ? args.active : undefined; + resourceInputs["contactEmail"] = args ? args.contactEmail : undefined; + resourceInputs["defaultTtl"] = args ? args.defaultTtl : undefined; + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["dnsName"] = args ? args.dnsName : undefined; + resourceInputs["expireTime"] = args ? args.expireTime : undefined; + resourceInputs["isReverseZone"] = args ? args.isReverseZone : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["negativeCache"] = args ? args.negativeCache : undefined; + resourceInputs["primaries"] = args ? args.primaries : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["refreshTime"] = args ? args.refreshTime : undefined; + resourceInputs["retryTime"] = args ? args.retryTime : undefined; + resourceInputs["type"] = args ? args.type : undefined; + resourceInputs["primaryNameServer"] = undefined /*out*/; + resourceInputs["recordCount"] = undefined /*out*/; + resourceInputs["serialNumber"] = undefined /*out*/; + resourceInputs["state"] = undefined /*out*/; + resourceInputs["visibility"] = undefined /*out*/; + resourceInputs["zoneId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(DnsZone.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering DnsZone resources. + */ +export interface DnsZoneState { + /** + * The access control list. E.g. `0.0.0.0/0,::/0` + */ + acl?: pulumi.Input; + active?: pulumi.Input; + /** + * A contact e-mail for the zone. + */ + contactEmail?: pulumi.Input; + /** + * Default time to live. E.g. 3600. + */ + defaultTtl?: pulumi.Input; + /** + * Description of the zone. + */ + description?: pulumi.Input; + /** + * The zone name. E.g. `example.com` + */ + dnsName?: pulumi.Input; + /** + * Expire time. E.g. 1209600. + */ + expireTime?: pulumi.Input; + /** + * Specifies, if the zone is a reverse zone or not. Defaults to `false` + */ + isReverseZone?: pulumi.Input; + /** + * The user given name of the zone. + */ + name?: pulumi.Input; + /** + * Negative caching. E.g. 60 + */ + negativeCache?: pulumi.Input; + /** + * Primary name server for secondary zone. E.g. ["1.2.3.4"] + */ + primaries?: pulumi.Input[]>; + /** + * Primary name server. FQDN. + */ + primaryNameServer?: pulumi.Input; + /** + * STACKIT project ID to which the dns zone is associated. + */ + projectId?: pulumi.Input; + /** + * Record count how many records are in the zone. + */ + recordCount?: pulumi.Input; + /** + * Refresh time. E.g. 3600 + */ + refreshTime?: pulumi.Input; + /** + * Retry time. E.g. 600 + */ + retryTime?: pulumi.Input; + /** + * Serial number. E.g. `2022111400`. + */ + serialNumber?: pulumi.Input; + /** + * Zone state. E.g. `CREATE_SUCCEEDED`. + */ + state?: pulumi.Input; + /** + * Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + */ + type?: pulumi.Input; + /** + * Visibility of the zone. E.g. `public`. + */ + visibility?: pulumi.Input; + /** + * The zone ID. + */ + zoneId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a DnsZone resource. + */ +export interface DnsZoneArgs { + /** + * The access control list. E.g. `0.0.0.0/0,::/0` + */ + acl?: pulumi.Input; + active?: pulumi.Input; + /** + * A contact e-mail for the zone. + */ + contactEmail?: pulumi.Input; + /** + * Default time to live. E.g. 3600. + */ + defaultTtl?: pulumi.Input; + /** + * Description of the zone. + */ + description?: pulumi.Input; + /** + * The zone name. E.g. `example.com` + */ + dnsName: pulumi.Input; + /** + * Expire time. E.g. 1209600. + */ + expireTime?: pulumi.Input; + /** + * Specifies, if the zone is a reverse zone or not. Defaults to `false` + */ + isReverseZone?: pulumi.Input; + /** + * The user given name of the zone. + */ + name?: pulumi.Input; + /** + * Negative caching. E.g. 60 + */ + negativeCache?: pulumi.Input; + /** + * Primary name server for secondary zone. E.g. ["1.2.3.4"] + */ + primaries?: pulumi.Input[]>; + /** + * STACKIT project ID to which the dns zone is associated. + */ + projectId: pulumi.Input; + /** + * Refresh time. E.g. 3600 + */ + refreshTime?: pulumi.Input; + /** + * Retry time. E.g. 600 + */ + retryTime?: pulumi.Input; + /** + * Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + */ + type?: pulumi.Input; +} diff --git a/sdk/nodejs/getAffinityGroup.ts b/sdk/nodejs/getAffinityGroup.ts new file mode 100644 index 0000000..8b0426d --- /dev/null +++ b/sdk/nodejs/getAffinityGroup.ts @@ -0,0 +1,85 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Affinity Group schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getAffinityGroup(args: GetAffinityGroupArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getAffinityGroup:getAffinityGroup", { + "affinityGroupId": args.affinityGroupId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getAffinityGroup. + */ +export interface GetAffinityGroupArgs { + /** + * The affinity group ID. + */ + affinityGroupId: string; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getAffinityGroup. + */ +export interface GetAffinityGroupResult { + /** + * The affinity group ID. + */ + readonly affinityGroupId: string; + readonly id: string; + /** + * Affinity Group schema. Must have a `region` specified in the provider configuration. + */ + readonly members: string[]; + /** + * The name of the affinity group. + */ + readonly name: string; + /** + * The policy of the affinity group. + */ + readonly policy: string; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + readonly projectId: string; +} +/** + * Affinity Group schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getAffinityGroupOutput(args: GetAffinityGroupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getAffinityGroup:getAffinityGroup", { + "affinityGroupId": args.affinityGroupId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getAffinityGroup. + */ +export interface GetAffinityGroupOutputArgs { + /** + * The affinity group ID. + */ + affinityGroupId: pulumi.Input; + /** + * STACKIT Project ID to which the affinity group is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getCdnCustomDomain.ts b/sdk/nodejs/getCdnCustomDomain.ts new file mode 100644 index 0000000..57fcf1a --- /dev/null +++ b/sdk/nodejs/getCdnCustomDomain.ts @@ -0,0 +1,90 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getCdnCustomDomain(args: GetCdnCustomDomainArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getCdnCustomDomain:getCdnCustomDomain", { + "distributionId": args.distributionId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getCdnCustomDomain. + */ +export interface GetCdnCustomDomainArgs { + /** + * CDN distribution ID + */ + distributionId: string; + name: string; + /** + * STACKIT project ID associated with the distribution + */ + projectId: string; +} + +/** + * A collection of values returned by getCdnCustomDomain. + */ +export interface GetCdnCustomDomainResult { + /** + * CDN distribution ID + */ + readonly distributionId: string; + /** + * List of distribution errors + */ + readonly errors: string[]; + readonly id: string; + readonly name: string; + /** + * STACKIT project ID associated with the distribution + */ + readonly projectId: string; + /** + * Status of the distribution + */ + readonly status: string; +} +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getCdnCustomDomainOutput(args: GetCdnCustomDomainOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getCdnCustomDomain:getCdnCustomDomain", { + "distributionId": args.distributionId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getCdnCustomDomain. + */ +export interface GetCdnCustomDomainOutputArgs { + /** + * CDN distribution ID + */ + distributionId: pulumi.Input; + name: pulumi.Input; + /** + * STACKIT project ID associated with the distribution + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getCdnDistribution.ts b/sdk/nodejs/getCdnDistribution.ts new file mode 100644 index 0000000..e9c82d9 --- /dev/null +++ b/sdk/nodejs/getCdnDistribution.ts @@ -0,0 +1,103 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getCdnDistribution(args: GetCdnDistributionArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getCdnDistribution:getCdnDistribution", { + "distributionId": args.distributionId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getCdnDistribution. + */ +export interface GetCdnDistributionArgs { + /** + * STACKIT project ID associated with the distribution + */ + distributionId: string; + /** + * STACKIT project ID associated with the distribution + */ + projectId: string; +} + +/** + * A collection of values returned by getCdnDistribution. + */ +export interface GetCdnDistributionResult { + /** + * The distribution configuration + */ + readonly config: outputs.GetCdnDistributionConfig; + /** + * Time when the distribution was created + */ + readonly createdAt: string; + /** + * STACKIT project ID associated with the distribution + */ + readonly distributionId: string; + /** + * List of configured domains for the distribution + */ + readonly domains: outputs.GetCdnDistributionDomain[]; + /** + * List of distribution errors + */ + readonly errors: string[]; + readonly id: string; + /** + * STACKIT project ID associated with the distribution + */ + readonly projectId: string; + /** + * Status of the distribution + */ + readonly status: string; + /** + * Time when the distribution was last updated + */ + readonly updatedAt: string; +} +/** + * CDN distribution data source schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getCdnDistributionOutput(args: GetCdnDistributionOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getCdnDistribution:getCdnDistribution", { + "distributionId": args.distributionId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getCdnDistribution. + */ +export interface GetCdnDistributionOutputArgs { + /** + * STACKIT project ID associated with the distribution + */ + distributionId: pulumi.Input; + /** + * STACKIT project ID associated with the distribution + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getDnsRecordSet.ts b/sdk/nodejs/getDnsRecordSet.ts new file mode 100644 index 0000000..878c646 --- /dev/null +++ b/sdk/nodejs/getDnsRecordSet.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * DNS Record Set Resource schema. + * + * ## Example Usage + */ +export function getDnsRecordSet(args: GetDnsRecordSetArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getDnsRecordSet:getDnsRecordSet", { + "projectId": args.projectId, + "recordSetId": args.recordSetId, + "zoneId": args.zoneId, + }, opts); +} + +/** + * A collection of arguments for invoking getDnsRecordSet. + */ +export interface GetDnsRecordSetArgs { + /** + * STACKIT project ID to which the dns record set is associated. + */ + projectId: string; + /** + * The rr set id. + */ + recordSetId: string; + /** + * The zone ID to which is dns record set is associated. + */ + zoneId: string; +} + +/** + * A collection of values returned by getDnsRecordSet. + */ +export interface GetDnsRecordSetResult { + /** + * Specifies if the record set is active or not. + */ + readonly active: boolean; + /** + * Comment. + */ + readonly comment: string; + /** + * Error shows error in case create/update/delete failed. + */ + readonly error: string; + /** + * Fully qualified domain name (FQDN) of the record set. + */ + readonly fqdn: string; + readonly id: string; + /** + * Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + */ + readonly name: string; + /** + * STACKIT project ID to which the dns record set is associated. + */ + readonly projectId: string; + /** + * The rr set id. + */ + readonly recordSetId: string; + /** + * Records. + */ + readonly records: string[]; + /** + * Record set state. + */ + readonly state: string; + /** + * Time to live. E.g. 3600 + */ + readonly ttl: number; + /** + * The record set type. E.g. `A` or `CNAME` + */ + readonly type: string; + /** + * The zone ID to which is dns record set is associated. + */ + readonly zoneId: string; +} +/** + * DNS Record Set Resource schema. + * + * ## Example Usage + */ +export function getDnsRecordSetOutput(args: GetDnsRecordSetOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getDnsRecordSet:getDnsRecordSet", { + "projectId": args.projectId, + "recordSetId": args.recordSetId, + "zoneId": args.zoneId, + }, opts); +} + +/** + * A collection of arguments for invoking getDnsRecordSet. + */ +export interface GetDnsRecordSetOutputArgs { + /** + * STACKIT project ID to which the dns record set is associated. + */ + projectId: pulumi.Input; + /** + * The rr set id. + */ + recordSetId: pulumi.Input; + /** + * The zone ID to which is dns record set is associated. + */ + zoneId: pulumi.Input; +} diff --git a/sdk/nodejs/getDnsZone.ts b/sdk/nodejs/getDnsZone.ts new file mode 100644 index 0000000..f3d2347 --- /dev/null +++ b/sdk/nodejs/getDnsZone.ts @@ -0,0 +1,156 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * DNS Zone resource schema. + * + * ## Example Usage + */ +export function getDnsZone(args: GetDnsZoneArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getDnsZone:getDnsZone", { + "dnsName": args.dnsName, + "projectId": args.projectId, + "zoneId": args.zoneId, + }, opts); +} + +/** + * A collection of arguments for invoking getDnsZone. + */ +export interface GetDnsZoneArgs { + /** + * The zone name. E.g. `example.com` + */ + dnsName?: string; + /** + * STACKIT project ID to which the dns zone is associated. + */ + projectId: string; + /** + * The zone ID. + */ + zoneId?: string; +} + +/** + * A collection of values returned by getDnsZone. + */ +export interface GetDnsZoneResult { + /** + * The access control list. + */ + readonly acl: string; + readonly active: boolean; + /** + * A contact e-mail for the zone. + */ + readonly contactEmail: string; + /** + * Default time to live. + */ + readonly defaultTtl: number; + /** + * Description of the zone. + */ + readonly description: string; + /** + * The zone name. E.g. `example.com` + */ + readonly dnsName?: string; + /** + * Expire time. + */ + readonly expireTime: number; + readonly id: string; + /** + * Specifies, if the zone is a reverse zone or not. + */ + readonly isReverseZone: boolean; + /** + * The user given name of the zone. + */ + readonly name: string; + /** + * Negative caching. + */ + readonly negativeCache: number; + /** + * Primary name server for secondary zone. + */ + readonly primaries: string[]; + /** + * Primary name server. FQDN. + */ + readonly primaryNameServer: string; + /** + * STACKIT project ID to which the dns zone is associated. + */ + readonly projectId: string; + /** + * Record count how many records are in the zone. + */ + readonly recordCount: number; + /** + * Refresh time. + */ + readonly refreshTime: number; + /** + * Retry time. + */ + readonly retryTime: number; + /** + * Serial number. + */ + readonly serialNumber: number; + /** + * Zone state. + */ + readonly state: string; + /** + * Zone type. + */ + readonly type: string; + /** + * Visibility of the zone. + */ + readonly visibility: string; + /** + * The zone ID. + */ + readonly zoneId?: string; +} +/** + * DNS Zone resource schema. + * + * ## Example Usage + */ +export function getDnsZoneOutput(args: GetDnsZoneOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getDnsZone:getDnsZone", { + "dnsName": args.dnsName, + "projectId": args.projectId, + "zoneId": args.zoneId, + }, opts); +} + +/** + * A collection of arguments for invoking getDnsZone. + */ +export interface GetDnsZoneOutputArgs { + /** + * The zone name. E.g. `example.com` + */ + dnsName?: pulumi.Input; + /** + * STACKIT project ID to which the dns zone is associated. + */ + projectId: pulumi.Input; + /** + * The zone ID. + */ + zoneId?: pulumi.Input; +} diff --git a/sdk/nodejs/getGit.ts b/sdk/nodejs/getGit.ts new file mode 100644 index 0000000..48e5167 --- /dev/null +++ b/sdk/nodejs/getGit.ts @@ -0,0 +1,89 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Git Instance datasource schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getGit(args: GetGitArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getGit:getGit", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getGit. + */ +export interface GetGitArgs { + /** + * ID linked to the git instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the git instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getGit. + */ +export interface GetGitResult { + readonly id: string; + /** + * ID linked to the git instance. + */ + readonly instanceId: string; + /** + * Unique name linked to the git instance. + */ + readonly name: string; + /** + * STACKIT project ID to which the git instance is associated. + */ + readonly projectId: string; + /** + * Url linked to the git instance. + */ + readonly url: string; + /** + * Version linked to the git instance. + */ + readonly version: string; +} +/** + * Git Instance datasource schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getGitOutput(args: GetGitOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getGit:getGit", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getGit. + */ +export interface GetGitOutputArgs { + /** + * ID linked to the git instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the git instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getImage.ts b/sdk/nodejs/getImage.ts new file mode 100644 index 0000000..e08a276 --- /dev/null +++ b/sdk/nodejs/getImage.ts @@ -0,0 +1,111 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Image datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getImage(args: GetImageArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getImage:getImage", { + "imageId": args.imageId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getImage. + */ +export interface GetImageArgs { + /** + * The image ID. + */ + imageId: string; + /** + * STACKIT project ID to which the image is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getImage. + */ +export interface GetImageResult { + /** + * Representation of an image checksum. + */ + readonly checksum: outputs.GetImageChecksum; + /** + * Properties to set hardware and scheduling settings for an image. + */ + readonly config: outputs.GetImageConfig; + /** + * The disk format of the image. + */ + readonly diskFormat: string; + readonly id: string; + /** + * The image ID. + */ + readonly imageId: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The minimum disk size of the image in GB. + */ + readonly minDiskSize: number; + /** + * The minimum RAM of the image in MB. + */ + readonly minRam: number; + /** + * The name of the image. + */ + readonly name: string; + /** + * STACKIT project ID to which the image is associated. + */ + readonly projectId: string; + /** + * Whether the image is protected. + */ + readonly protected: boolean; + /** + * The scope of the image. + */ + readonly scope: string; +} +/** + * Image datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getImageOutput(args: GetImageOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getImage:getImage", { + "imageId": args.imageId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getImage. + */ +export interface GetImageOutputArgs { + /** + * The image ID. + */ + imageId: pulumi.Input; + /** + * STACKIT project ID to which the image is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getKeyPair.ts b/sdk/nodejs/getKeyPair.ts new file mode 100644 index 0000000..e9291d3 --- /dev/null +++ b/sdk/nodejs/getKeyPair.ts @@ -0,0 +1,71 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Key pair resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getKeyPair(args: GetKeyPairArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getKeyPair:getKeyPair", { + "name": args.name, + }, opts); +} + +/** + * A collection of arguments for invoking getKeyPair. + */ +export interface GetKeyPairArgs { + /** + * The name of the SSH key pair. + */ + name: string; +} + +/** + * A collection of values returned by getKeyPair. + */ +export interface GetKeyPairResult { + /** + * The fingerprint of the public SSH key. + */ + readonly fingerprint: string; + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container. + */ + readonly labels: {[key: string]: string}; + /** + * The name of the SSH key pair. + */ + readonly name: string; + /** + * A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + */ + readonly publicKey: string; +} +/** + * Key pair resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getKeyPairOutput(args: GetKeyPairOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getKeyPair:getKeyPair", { + "name": args.name, + }, opts); +} + +/** + * A collection of arguments for invoking getKeyPair. + */ +export interface GetKeyPairOutputArgs { + /** + * The name of the SSH key pair. + */ + name: pulumi.Input; +} diff --git a/sdk/nodejs/getLoadbalancer.ts b/sdk/nodejs/getLoadbalancer.ts new file mode 100644 index 0000000..cfaa59f --- /dev/null +++ b/sdk/nodejs/getLoadbalancer.ts @@ -0,0 +1,113 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Load Balancer data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLoadbalancer(args: GetLoadbalancerArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getLoadbalancer:getLoadbalancer", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getLoadbalancer. + */ +export interface GetLoadbalancerArgs { + /** + * Load balancer name. + */ + name: string; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getLoadbalancer. + */ +export interface GetLoadbalancerResult { + /** + * External Load Balancer IP address where this Load Balancer is exposed. + */ + readonly externalAddress: string; + readonly id: string; + /** + * List of all listeners which will accept traffic. Limited to 20. + */ + readonly listeners: outputs.GetLoadbalancerListener[]; + /** + * Load balancer name. + */ + readonly name: string; + /** + * List of networks that listeners and targets reside in. + */ + readonly networks: outputs.GetLoadbalancerNetwork[]; + /** + * Defines any optional functionality you want to have enabled on your load balancer. + */ + readonly options: outputs.GetLoadbalancerOptions; + /** + * Transient private Load Balancer IP address. It can change any time. + */ + readonly privateAddress: string; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * List of all target pools which will be used in the Load Balancer. Limited to 20. + */ + readonly targetPools: outputs.GetLoadbalancerTargetPool[]; +} +/** + * Load Balancer data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLoadbalancerOutput(args: GetLoadbalancerOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getLoadbalancer:getLoadbalancer", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getLoadbalancer. + */ +export interface GetLoadbalancerOutputArgs { + /** + * Load balancer name. + */ + name: pulumi.Input; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getLogmeCredential.ts b/sdk/nodejs/getLogmeCredential.ts new file mode 100644 index 0000000..e4d3c08 --- /dev/null +++ b/sdk/nodejs/getLogmeCredential.ts @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * LogMe credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLogmeCredential(args: GetLogmeCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getLogmeCredential:getLogmeCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getLogmeCredential. + */ +export interface GetLogmeCredentialArgs { + /** + * The credential's ID. + */ + credentialId: string; + /** + * ID of the LogMe instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getLogmeCredential. + */ +export interface GetLogmeCredentialResult { + /** + * The credential's ID. + */ + readonly credentialId: string; + readonly host: string; + readonly id: string; + /** + * ID of the LogMe instance. + */ + readonly instanceId: string; + readonly password: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly uri: string; + readonly username: string; +} +/** + * LogMe credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLogmeCredentialOutput(args: GetLogmeCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getLogmeCredential:getLogmeCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getLogmeCredential. + */ +export interface GetLogmeCredentialOutputArgs { + /** + * The credential's ID. + */ + credentialId: pulumi.Input; + /** + * ID of the LogMe instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getLogmeInstance.ts b/sdk/nodejs/getLogmeInstance.ts new file mode 100644 index 0000000..c6c462b --- /dev/null +++ b/sdk/nodejs/getLogmeInstance.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * LogMe instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLogmeInstance(args: GetLogmeInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getLogmeInstance:getLogmeInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getLogmeInstance. + */ +export interface GetLogmeInstanceArgs { + /** + * ID of the LogMe instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getLogmeInstance. + */ +export interface GetLogmeInstanceResult { + readonly cfGuid: string; + readonly cfOrganizationGuid: string; + readonly cfSpaceGuid: string; + readonly dashboardUrl: string; + readonly id: string; + readonly imageUrl: string; + /** + * ID of the LogMe instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + readonly parameters: outputs.GetLogmeInstanceParameters; + /** + * The selected plan ID. + */ + readonly planId: string; + /** + * The selected plan name. + */ + readonly planName: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The service version. + */ + readonly version: string; +} +/** + * LogMe instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getLogmeInstanceOutput(args: GetLogmeInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getLogmeInstance:getLogmeInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getLogmeInstance. + */ +export interface GetLogmeInstanceOutputArgs { + /** + * ID of the LogMe instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getMariadbCredential.ts b/sdk/nodejs/getMariadbCredential.ts new file mode 100644 index 0000000..d3a4f45 --- /dev/null +++ b/sdk/nodejs/getMariadbCredential.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMariadbCredential(args: GetMariadbCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getMariadbCredential:getMariadbCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMariadbCredential. + */ +export interface GetMariadbCredentialArgs { + /** + * The credential's ID. + */ + credentialId: string; + /** + * ID of the MariaDB instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getMariadbCredential. + */ +export interface GetMariadbCredentialResult { + /** + * The credential's ID. + */ + readonly credentialId: string; + readonly host: string; + readonly hosts: string[]; + readonly id: string; + /** + * ID of the MariaDB instance. + */ + readonly instanceId: string; + readonly name: string; + readonly password: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly uri: string; + readonly username: string; +} +/** + * MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMariadbCredentialOutput(args: GetMariadbCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getMariadbCredential:getMariadbCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMariadbCredential. + */ +export interface GetMariadbCredentialOutputArgs { + /** + * The credential's ID. + */ + credentialId: pulumi.Input; + /** + * ID of the MariaDB instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getMariadbInstance.ts b/sdk/nodejs/getMariadbInstance.ts new file mode 100644 index 0000000..8837a12 --- /dev/null +++ b/sdk/nodejs/getMariadbInstance.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMariadbInstance(args: GetMariadbInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getMariadbInstance:getMariadbInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMariadbInstance. + */ +export interface GetMariadbInstanceArgs { + /** + * ID of the MariaDB instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getMariadbInstance. + */ +export interface GetMariadbInstanceResult { + readonly cfGuid: string; + readonly cfOrganizationGuid: string; + readonly cfSpaceGuid: string; + readonly dashboardUrl: string; + readonly id: string; + readonly imageUrl: string; + /** + * ID of the MariaDB instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + readonly parameters: outputs.GetMariadbInstanceParameters; + /** + * The selected plan ID. + */ + readonly planId: string; + /** + * The selected plan name. + */ + readonly planName: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The service version. + */ + readonly version: string; +} +/** + * MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMariadbInstanceOutput(args: GetMariadbInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getMariadbInstance:getMariadbInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMariadbInstance. + */ +export interface GetMariadbInstanceOutputArgs { + /** + * ID of the MariaDB instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getMongodbflexInstance.ts b/sdk/nodejs/getMongodbflexInstance.ts new file mode 100644 index 0000000..30f4104 --- /dev/null +++ b/sdk/nodejs/getMongodbflexInstance.ts @@ -0,0 +1,95 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMongodbflexInstance(args: GetMongodbflexInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getMongodbflexInstance:getMongodbflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMongodbflexInstance. + */ +export interface GetMongodbflexInstanceArgs { + /** + * ID of the MongoDB Flex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getMongodbflexInstance. + */ +export interface GetMongodbflexInstanceResult { + /** + * The Access Control List (ACL) for the MongoDB Flex instance. + */ + readonly acls: string[]; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + */ + readonly backupSchedule: string; + readonly flavor: outputs.GetMongodbflexInstanceFlavor; + readonly id: string; + /** + * ID of the MongoDB Flex instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + /** + * Custom parameters for the MongoDB Flex instance. + */ + readonly options: outputs.GetMongodbflexInstanceOptions; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly replicas: number; + readonly storage: outputs.GetMongodbflexInstanceStorage; + readonly version: string; +} +/** + * MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMongodbflexInstanceOutput(args: GetMongodbflexInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getMongodbflexInstance:getMongodbflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getMongodbflexInstance. + */ +export interface GetMongodbflexInstanceOutputArgs { + /** + * ID of the MongoDB Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getMongodbflexUser.ts b/sdk/nodejs/getMongodbflexUser.ts new file mode 100644 index 0000000..849fc9a --- /dev/null +++ b/sdk/nodejs/getMongodbflexUser.ts @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMongodbflexUser(args: GetMongodbflexUserArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getMongodbflexUser:getMongodbflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getMongodbflexUser. + */ +export interface GetMongodbflexUserArgs { + /** + * ID of the MongoDB Flex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * User ID. + */ + userId: string; +} + +/** + * A collection of values returned by getMongodbflexUser. + */ +export interface GetMongodbflexUserResult { + readonly database: string; + readonly host: string; + readonly id: string; + /** + * ID of the MongoDB Flex instance. + */ + readonly instanceId: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly roles: string[]; + /** + * User ID. + */ + readonly userId: string; + readonly username: string; +} +/** + * MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getMongodbflexUserOutput(args: GetMongodbflexUserOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getMongodbflexUser:getMongodbflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getMongodbflexUser. + */ +export interface GetMongodbflexUserOutputArgs { + /** + * ID of the MongoDB Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * User ID. + */ + userId: pulumi.Input; +} diff --git a/sdk/nodejs/getNetwork.ts b/sdk/nodejs/getNetwork.ts new file mode 100644 index 0000000..1ed1738 --- /dev/null +++ b/sdk/nodejs/getNetwork.ts @@ -0,0 +1,145 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetwork(args: GetNetworkArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getNetwork:getNetwork", { + "networkId": args.networkId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetwork. + */ +export interface GetNetworkArgs { + /** + * The network ID. + */ + networkId: string; + /** + * STACKIT project ID to which the network is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getNetwork. + */ +export interface GetNetworkResult { + readonly id: string; + /** + * The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + readonly ipv4Gateway: string; + /** + * The IPv4 nameservers of the network. + */ + readonly ipv4Nameservers: string[]; + /** + * The IPv4 prefix of the network (CIDR). + * + * @deprecated The API supports reading multiple prefixes. So using the attribute 'ipv4_prefixes` should be preferred. This attribute will be populated with the first element from the list + */ + readonly ipv4Prefix: string; + /** + * The IPv4 prefix length of the network. + */ + readonly ipv4PrefixLength: number; + /** + * The IPv4 prefixes of the network. + */ + readonly ipv4Prefixes: string[]; + /** + * The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + readonly ipv6Gateway: string; + /** + * The IPv6 nameservers of the network. + */ + readonly ipv6Nameservers: string[]; + /** + * The IPv6 prefix of the network (CIDR). + * + * @deprecated The API supports reading multiple prefixes. So using the attribute 'ipv6_prefixes` should be preferred. This attribute will be populated with the first element from the list + */ + readonly ipv6Prefix: string; + /** + * The IPv6 prefix length of the network. + */ + readonly ipv6PrefixLength: number; + /** + * The IPv6 prefixes of the network. + */ + readonly ipv6Prefixes: string[]; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The name of the network. + */ + readonly name: string; + /** + * The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + * + * @deprecated Use `ipv4Nameservers` to configure the nameservers for IPv4. + */ + readonly nameservers: string[]; + /** + * The network ID. + */ + readonly networkId: string; + /** + * The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + * + * @deprecated Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + */ + readonly prefixes: string[]; + /** + * STACKIT project ID to which the network is associated. + */ + readonly projectId: string; + /** + * The public IP of the network. + */ + readonly publicIp: string; + /** + * Shows if the network is routed and therefore accessible from other networks. + */ + readonly routed: boolean; +} +/** + * Network resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkOutput(args: GetNetworkOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getNetwork:getNetwork", { + "networkId": args.networkId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetwork. + */ +export interface GetNetworkOutputArgs { + /** + * The network ID. + */ + networkId: pulumi.Input; + /** + * STACKIT project ID to which the network is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getNetworkArea.ts b/sdk/nodejs/getNetworkArea.ts new file mode 100644 index 0000000..248f765 --- /dev/null +++ b/sdk/nodejs/getNetworkArea.ts @@ -0,0 +1,111 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network area datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkArea(args: GetNetworkAreaArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getNetworkArea:getNetworkArea", { + "networkAreaId": args.networkAreaId, + "organizationId": args.organizationId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkArea. + */ +export interface GetNetworkAreaArgs { + /** + * The network area ID. + */ + networkAreaId: string; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: string; +} + +/** + * A collection of values returned by getNetworkArea. + */ +export interface GetNetworkAreaResult { + /** + * List of DNS Servers/Nameservers. + */ + readonly defaultNameservers: string[]; + /** + * The default prefix length for networks in the network area. + */ + readonly defaultPrefixLength: number; + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The maximal prefix length for networks in the network area. + */ + readonly maxPrefixLength: number; + /** + * The minimal prefix length for networks in the network area. + */ + readonly minPrefixLength: number; + /** + * The name of the network area. + */ + readonly name: string; + /** + * The network area ID. + */ + readonly networkAreaId: string; + /** + * List of Network ranges. + */ + readonly networkRanges: outputs.GetNetworkAreaNetworkRange[]; + /** + * STACKIT organization ID to which the network area is associated. + */ + readonly organizationId: string; + /** + * The amount of projects currently referencing this area. + */ + readonly projectCount: number; + /** + * Classless Inter-Domain Routing (CIDR). + */ + readonly transferNetwork: string; +} +/** + * Network area datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkAreaOutput(args: GetNetworkAreaOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getNetworkArea:getNetworkArea", { + "networkAreaId": args.networkAreaId, + "organizationId": args.organizationId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkArea. + */ +export interface GetNetworkAreaOutputArgs { + /** + * The network area ID. + */ + networkAreaId: pulumi.Input; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: pulumi.Input; +} diff --git a/sdk/nodejs/getNetworkAreaRoute.ts b/sdk/nodejs/getNetworkAreaRoute.ts new file mode 100644 index 0000000..24951f5 --- /dev/null +++ b/sdk/nodejs/getNetworkAreaRoute.ts @@ -0,0 +1,99 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network area route data resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkAreaRoute(args: GetNetworkAreaRouteArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", { + "networkAreaId": args.networkAreaId, + "networkAreaRouteId": args.networkAreaRouteId, + "organizationId": args.organizationId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkAreaRoute. + */ +export interface GetNetworkAreaRouteArgs { + /** + * The network area ID to which the network area route is associated. + */ + networkAreaId: string; + /** + * The network area route ID. + */ + networkAreaRouteId: string; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: string; +} + +/** + * A collection of values returned by getNetworkAreaRoute. + */ +export interface GetNetworkAreaRouteResult { + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The network area ID to which the network area route is associated. + */ + readonly networkAreaId: string; + /** + * The network area route ID. + */ + readonly networkAreaRouteId: string; + /** + * The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + */ + readonly nextHop: string; + /** + * STACKIT organization ID to which the network area is associated. + */ + readonly organizationId: string; + /** + * The network, that is reachable though the Next Hop. Should use CIDR notation. + */ + readonly prefix: string; +} +/** + * Network area route data resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkAreaRouteOutput(args: GetNetworkAreaRouteOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getNetworkAreaRoute:getNetworkAreaRoute", { + "networkAreaId": args.networkAreaId, + "networkAreaRouteId": args.networkAreaRouteId, + "organizationId": args.organizationId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkAreaRoute. + */ +export interface GetNetworkAreaRouteOutputArgs { + /** + * The network area ID to which the network area route is associated. + */ + networkAreaId: pulumi.Input; + /** + * The network area route ID. + */ + networkAreaRouteId: pulumi.Input; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: pulumi.Input; +} diff --git a/sdk/nodejs/getNetworkInterface.ts b/sdk/nodejs/getNetworkInterface.ts new file mode 100644 index 0000000..e0ef876 --- /dev/null +++ b/sdk/nodejs/getNetworkInterface.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network interface datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkInterface(args: GetNetworkInterfaceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getNetworkInterface:getNetworkInterface", { + "networkId": args.networkId, + "networkInterfaceId": args.networkInterfaceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkInterface. + */ +export interface GetNetworkInterfaceArgs { + /** + * The network ID to which the network interface is associated. + */ + networkId: string; + /** + * The network interface ID. + */ + networkInterfaceId: string; + /** + * STACKIT project ID to which the network interface is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getNetworkInterface. + */ +export interface GetNetworkInterfaceResult { + /** + * The list of CIDR (Classless Inter-Domain Routing) notations. + */ + readonly allowedAddresses: string[]; + /** + * The device UUID of the network interface. + */ + readonly device: string; + readonly id: string; + /** + * The IPv4 address. + */ + readonly ipv4: string; + /** + * Labels are key-value string pairs which can be attached to a network interface. + */ + readonly labels: {[key: string]: string}; + /** + * The MAC address of network interface. + */ + readonly mac: string; + /** + * The name of the network interface. + */ + readonly name: string; + /** + * The network ID to which the network interface is associated. + */ + readonly networkId: string; + /** + * The network interface ID. + */ + readonly networkInterfaceId: string; + /** + * STACKIT project ID to which the network interface is associated. + */ + readonly projectId: string; + /** + * The Network Interface Security. If set to false, then no security groups will apply to this network interface. + */ + readonly security: boolean; + /** + * The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + */ + readonly securityGroupIds: string[]; + /** + * Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + */ + readonly type: string; +} +/** + * Network interface datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getNetworkInterfaceOutput(args: GetNetworkInterfaceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getNetworkInterface:getNetworkInterface", { + "networkId": args.networkId, + "networkInterfaceId": args.networkInterfaceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getNetworkInterface. + */ +export interface GetNetworkInterfaceOutputArgs { + /** + * The network ID to which the network interface is associated. + */ + networkId: pulumi.Input; + /** + * The network interface ID. + */ + networkInterfaceId: pulumi.Input; + /** + * STACKIT project ID to which the network interface is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getObjectstorageBucket.ts b/sdk/nodejs/getObjectstorageBucket.ts new file mode 100644 index 0000000..3e21da9 --- /dev/null +++ b/sdk/nodejs/getObjectstorageBucket.ts @@ -0,0 +1,89 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageBucket(args: GetObjectstorageBucketArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObjectstorageBucket:getObjectstorageBucket", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageBucket. + */ +export interface GetObjectstorageBucketArgs { + /** + * The bucket name. It must be DNS conform. + */ + name: string; + /** + * STACKIT Project ID to which the bucket is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getObjectstorageBucket. + */ +export interface GetObjectstorageBucketResult { + readonly id: string; + /** + * The bucket name. It must be DNS conform. + */ + readonly name: string; + /** + * STACKIT Project ID to which the bucket is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + readonly urlPathStyle: string; + readonly urlVirtualHostedStyle: string; +} +/** + * ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageBucketOutput(args: GetObjectstorageBucketOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObjectstorageBucket:getObjectstorageBucket", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageBucket. + */ +export interface GetObjectstorageBucketOutputArgs { + /** + * The bucket name. It must be DNS conform. + */ + name: pulumi.Input; + /** + * STACKIT Project ID to which the bucket is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getObjectstorageCredential.ts b/sdk/nodejs/getObjectstorageCredential.ts new file mode 100644 index 0000000..6d4a923 --- /dev/null +++ b/sdk/nodejs/getObjectstorageCredential.ts @@ -0,0 +1,103 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageCredential(args: GetObjectstorageCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObjectstorageCredential:getObjectstorageCredential", { + "credentialId": args.credentialId, + "credentialsGroupId": args.credentialsGroupId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageCredential. + */ +export interface GetObjectstorageCredentialArgs { + /** + * The credential ID. + */ + credentialId: string; + /** + * The credential group ID. + */ + credentialsGroupId: string; + /** + * STACKIT Project ID to which the credential group is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getObjectstorageCredential. + */ +export interface GetObjectstorageCredentialResult { + /** + * The credential ID. + */ + readonly credentialId: string; + /** + * The credential group ID. + */ + readonly credentialsGroupId: string; + readonly expirationTimestamp: string; + readonly id: string; + readonly name: string; + /** + * STACKIT Project ID to which the credential group is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; +} +/** + * ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageCredentialOutput(args: GetObjectstorageCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObjectstorageCredential:getObjectstorageCredential", { + "credentialId": args.credentialId, + "credentialsGroupId": args.credentialsGroupId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageCredential. + */ +export interface GetObjectstorageCredentialOutputArgs { + /** + * The credential ID. + */ + credentialId: pulumi.Input; + /** + * The credential group ID. + */ + credentialsGroupId: pulumi.Input; + /** + * STACKIT Project ID to which the credential group is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getObjectstorageCredentialsGroup.ts b/sdk/nodejs/getObjectstorageCredentialsGroup.ts new file mode 100644 index 0000000..77c29b5 --- /dev/null +++ b/sdk/nodejs/getObjectstorageCredentialsGroup.ts @@ -0,0 +1,95 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageCredentialsGroup(args: GetObjectstorageCredentialsGroupArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", { + "credentialsGroupId": args.credentialsGroupId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageCredentialsGroup. + */ +export interface GetObjectstorageCredentialsGroupArgs { + /** + * The credentials group ID. + */ + credentialsGroupId: string; + /** + * Object Storage Project ID to which the credentials group is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getObjectstorageCredentialsGroup. + */ +export interface GetObjectstorageCredentialsGroupResult { + /** + * The credentials group ID. + */ + readonly credentialsGroupId: string; + readonly id: string; + /** + * The credentials group's display name. + */ + readonly name: string; + /** + * Object Storage Project ID to which the credentials group is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Credentials group uniform resource name (URN) + */ + readonly urn: string; +} +/** + * ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObjectstorageCredentialsGroupOutput(args: GetObjectstorageCredentialsGroupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup", { + "credentialsGroupId": args.credentialsGroupId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getObjectstorageCredentialsGroup. + */ +export interface GetObjectstorageCredentialsGroupOutputArgs { + /** + * The credentials group ID. + */ + credentialsGroupId: pulumi.Input; + /** + * Object Storage Project ID to which the credentials group is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getObservabilityAlertgroup.ts b/sdk/nodejs/getObservabilityAlertgroup.ts new file mode 100644 index 0000000..7d290d1 --- /dev/null +++ b/sdk/nodejs/getObservabilityAlertgroup.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityAlertgroup(args: GetObservabilityAlertgroupArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityAlertgroup. + */ +export interface GetObservabilityAlertgroupArgs { + /** + * Observability instance ID to which the alert group is associated. + */ + instanceId: string; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + name: string; + /** + * STACKIT project ID to which the alert group is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getObservabilityAlertgroup. + */ +export interface GetObservabilityAlertgroupResult { + readonly id: string; + /** + * Observability instance ID to which the alert group is associated. + */ + readonly instanceId: string; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + readonly interval: string; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + readonly name: string; + /** + * STACKIT project ID to which the alert group is associated. + */ + readonly projectId: string; + readonly rules: outputs.GetObservabilityAlertgroupRule[]; +} +/** + * Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityAlertgroupOutput(args: GetObservabilityAlertgroupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityAlertgroup. + */ +export interface GetObservabilityAlertgroupOutputArgs { + /** + * Observability instance ID to which the alert group is associated. + */ + instanceId: pulumi.Input; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + name: pulumi.Input; + /** + * STACKIT project ID to which the alert group is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getObservabilityInstance.ts b/sdk/nodejs/getObservabilityInstance.ts new file mode 100644 index 0000000..5409716 --- /dev/null +++ b/sdk/nodejs/getObservabilityInstance.ts @@ -0,0 +1,163 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityInstance(args: GetObservabilityInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObservabilityInstance:getObservabilityInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityInstance. + */ +export interface GetObservabilityInstanceArgs { + /** + * The Observability instance ID. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getObservabilityInstance. + */ +export interface GetObservabilityInstanceResult { + /** + * The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + */ + readonly acls: string[]; + /** + * Alert configuration for the instance. + */ + readonly alertConfig: outputs.GetObservabilityInstanceAlertConfig; + /** + * Specifies Alerting URL. + */ + readonly alertingUrl: string; + /** + * Specifies Observability instance dashboard URL. + */ + readonly dashboardUrl: string; + /** + * Specifies an initial Grafana admin password. + */ + readonly grafanaInitialAdminPassword: string; + /** + * Specifies an initial Grafana admin username. + */ + readonly grafanaInitialAdminUser: string; + /** + * If true, anyone can access Grafana dashboards without logging in. + */ + readonly grafanaPublicReadAccess: boolean; + /** + * Specifies Grafana URL. + */ + readonly grafanaUrl: string; + readonly id: string; + /** + * The Observability instance ID. + */ + readonly instanceId: string; + /** + * Specifies if the instance can be updated. + */ + readonly isUpdatable: boolean; + readonly jaegerTracesUrl: string; + readonly jaegerUiUrl: string; + /** + * Specifies URL for pushing logs. + */ + readonly logsPushUrl: string; + /** + * Specifies Logs URL. + */ + readonly logsUrl: string; + /** + * Specifies URL for pushing metrics. + */ + readonly metricsPushUrl: string; + /** + * Specifies for how many days the raw metrics are kept. + */ + readonly metricsRetentionDays: number; + /** + * Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + */ + readonly metricsRetentionDays1hDownsampling: number; + /** + * Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + */ + readonly metricsRetentionDays5mDownsampling: number; + /** + * Specifies metrics URL. + */ + readonly metricsUrl: string; + /** + * The name of the Observability instance. + */ + readonly name: string; + readonly otlpTracesUrl: string; + /** + * Additional parameters. + */ + readonly parameters: {[key: string]: string}; + /** + * The Observability plan ID. + */ + readonly planId: string; + /** + * Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + */ + readonly planName: string; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * Specifies Targets URL. + */ + readonly targetsUrl: string; + readonly zipkinSpansUrl: string; +} +/** + * Observability instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityInstanceOutput(args: GetObservabilityInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObservabilityInstance:getObservabilityInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityInstance. + */ +export interface GetObservabilityInstanceOutputArgs { + /** + * The Observability instance ID. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getObservabilityLogalertgroup.ts b/sdk/nodejs/getObservabilityLogalertgroup.ts new file mode 100644 index 0000000..5e8ae7a --- /dev/null +++ b/sdk/nodejs/getObservabilityLogalertgroup.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityLogalertgroup(args: GetObservabilityLogalertgroupArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityLogalertgroup. + */ +export interface GetObservabilityLogalertgroupArgs { + /** + * Observability instance ID to which the log alert group is associated. + */ + instanceId: string; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + name: string; + /** + * STACKIT project ID to which the log alert group is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getObservabilityLogalertgroup. + */ +export interface GetObservabilityLogalertgroupResult { + readonly id: string; + /** + * Observability instance ID to which the log alert group is associated. + */ + readonly instanceId: string; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + readonly interval: string; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + readonly name: string; + /** + * STACKIT project ID to which the log alert group is associated. + */ + readonly projectId: string; + readonly rules: outputs.GetObservabilityLogalertgroupRule[]; +} +/** + * Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityLogalertgroupOutput(args: GetObservabilityLogalertgroupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityLogalertgroup. + */ +export interface GetObservabilityLogalertgroupOutputArgs { + /** + * Observability instance ID to which the log alert group is associated. + */ + instanceId: pulumi.Input; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + name: pulumi.Input; + /** + * STACKIT project ID to which the log alert group is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getObservabilityScrapeconfig.ts b/sdk/nodejs/getObservabilityScrapeconfig.ts new file mode 100644 index 0000000..bd4f925 --- /dev/null +++ b/sdk/nodejs/getObservabilityScrapeconfig.ts @@ -0,0 +1,121 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityScrapeconfig(args: GetObservabilityScrapeconfigArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityScrapeconfig. + */ +export interface GetObservabilityScrapeconfigArgs { + /** + * Observability instance ID to which the scraping job is associated. + */ + instanceId: string; + /** + * Specifies the name of the scraping job + */ + name: string; + /** + * STACKIT project ID to which the scraping job is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getObservabilityScrapeconfig. + */ +export interface GetObservabilityScrapeconfigResult { + /** + * A basic authentication block. + */ + readonly basicAuth: outputs.GetObservabilityScrapeconfigBasicAuth; + readonly id: string; + /** + * Observability instance ID to which the scraping job is associated. + */ + readonly instanceId: string; + /** + * Specifies the job scraping url path. + */ + readonly metricsPath: string; + /** + * Specifies the name of the scraping job + */ + readonly name: string; + /** + * STACKIT project ID to which the scraping job is associated. + */ + readonly projectId: string; + /** + * A SAML2 configuration block. + */ + readonly saml2: outputs.GetObservabilityScrapeconfigSaml2; + /** + * Specifies the scrape sample limit. + */ + readonly sampleLimit: number; + /** + * Specifies the http scheme. + */ + readonly scheme: string; + /** + * Specifies the scrape interval as duration string. + */ + readonly scrapeInterval: string; + /** + * Specifies the scrape timeout as duration string. + */ + readonly scrapeTimeout: string; + /** + * The targets list (specified by the static config). + */ + readonly targets: outputs.GetObservabilityScrapeconfigTarget[]; +} +/** + * Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getObservabilityScrapeconfigOutput(args: GetObservabilityScrapeconfigOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig", { + "instanceId": args.instanceId, + "name": args.name, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getObservabilityScrapeconfig. + */ +export interface GetObservabilityScrapeconfigOutputArgs { + /** + * Observability instance ID to which the scraping job is associated. + */ + instanceId: pulumi.Input; + /** + * Specifies the name of the scraping job + */ + name: pulumi.Input; + /** + * STACKIT project ID to which the scraping job is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getOpensearchCredential.ts b/sdk/nodejs/getOpensearchCredential.ts new file mode 100644 index 0000000..fdda75c --- /dev/null +++ b/sdk/nodejs/getOpensearchCredential.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getOpensearchCredential(args: GetOpensearchCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getOpensearchCredential:getOpensearchCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getOpensearchCredential. + */ +export interface GetOpensearchCredentialArgs { + /** + * The credential's ID. + */ + credentialId: string; + /** + * ID of the OpenSearch instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getOpensearchCredential. + */ +export interface GetOpensearchCredentialResult { + /** + * The credential's ID. + */ + readonly credentialId: string; + readonly host: string; + readonly hosts: string[]; + readonly id: string; + /** + * ID of the OpenSearch instance. + */ + readonly instanceId: string; + readonly password: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly scheme: string; + readonly uri: string; + readonly username: string; +} +/** + * OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getOpensearchCredentialOutput(args: GetOpensearchCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getOpensearchCredential:getOpensearchCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getOpensearchCredential. + */ +export interface GetOpensearchCredentialOutputArgs { + /** + * The credential's ID. + */ + credentialId: pulumi.Input; + /** + * ID of the OpenSearch instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getOpensearchInstance.ts b/sdk/nodejs/getOpensearchInstance.ts new file mode 100644 index 0000000..16872b8 --- /dev/null +++ b/sdk/nodejs/getOpensearchInstance.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getOpensearchInstance(args: GetOpensearchInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getOpensearchInstance:getOpensearchInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getOpensearchInstance. + */ +export interface GetOpensearchInstanceArgs { + /** + * ID of the OpenSearch instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getOpensearchInstance. + */ +export interface GetOpensearchInstanceResult { + readonly cfGuid: string; + readonly cfOrganizationGuid: string; + readonly cfSpaceGuid: string; + readonly dashboardUrl: string; + readonly id: string; + readonly imageUrl: string; + /** + * ID of the OpenSearch instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + readonly parameters: outputs.GetOpensearchInstanceParameters; + /** + * The selected plan ID. + */ + readonly planId: string; + /** + * The selected plan name. + */ + readonly planName: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The service version. + */ + readonly version: string; +} +/** + * OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getOpensearchInstanceOutput(args: GetOpensearchInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getOpensearchInstance:getOpensearchInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getOpensearchInstance. + */ +export interface GetOpensearchInstanceOutputArgs { + /** + * ID of the OpenSearch instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getPostgresflexDatabase.ts b/sdk/nodejs/getPostgresflexDatabase.ts new file mode 100644 index 0000000..5173a8f --- /dev/null +++ b/sdk/nodejs/getPostgresflexDatabase.ts @@ -0,0 +1,109 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexDatabase(args: GetPostgresflexDatabaseArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", { + "databaseId": args.databaseId, + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexDatabase. + */ +export interface GetPostgresflexDatabaseArgs { + /** + * Database ID. + */ + databaseId: string; + /** + * ID of the Postgres Flex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getPostgresflexDatabase. + */ +export interface GetPostgresflexDatabaseResult { + /** + * Database ID. + */ + readonly databaseId: string; + readonly id: string; + /** + * ID of the Postgres Flex instance. + */ + readonly instanceId: string; + /** + * Database name. + */ + readonly name: string; + /** + * Username of the database owner. + */ + readonly owner: string; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; +} +/** + * Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexDatabaseOutput(args: GetPostgresflexDatabaseOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getPostgresflexDatabase:getPostgresflexDatabase", { + "databaseId": args.databaseId, + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexDatabase. + */ +export interface GetPostgresflexDatabaseOutputArgs { + /** + * Database ID. + */ + databaseId: pulumi.Input; + /** + * ID of the Postgres Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getPostgresflexInstance.ts b/sdk/nodejs/getPostgresflexInstance.ts new file mode 100644 index 0000000..0678780 --- /dev/null +++ b/sdk/nodejs/getPostgresflexInstance.ts @@ -0,0 +1,102 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexInstance(args: GetPostgresflexInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getPostgresflexInstance:getPostgresflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexInstance. + */ +export interface GetPostgresflexInstanceArgs { + /** + * ID of the PostgresFlex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getPostgresflexInstance. + */ +export interface GetPostgresflexInstanceResult { + /** + * The Access Control List (ACL) for the PostgresFlex instance. + */ + readonly acls: string[]; + readonly backupSchedule: string; + readonly flavor: outputs.GetPostgresflexInstanceFlavor; + readonly id: string; + /** + * ID of the PostgresFlex instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + readonly replicas: number; + readonly storage: outputs.GetPostgresflexInstanceStorage; + readonly version: string; +} +/** + * Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexInstanceOutput(args: GetPostgresflexInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getPostgresflexInstance:getPostgresflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexInstance. + */ +export interface GetPostgresflexInstanceOutputArgs { + /** + * ID of the PostgresFlex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getPostgresflexUser.ts b/sdk/nodejs/getPostgresflexUser.ts new file mode 100644 index 0000000..2d6d6ff --- /dev/null +++ b/sdk/nodejs/getPostgresflexUser.ts @@ -0,0 +1,105 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexUser(args: GetPostgresflexUserArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getPostgresflexUser:getPostgresflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexUser. + */ +export interface GetPostgresflexUserArgs { + /** + * ID of the PostgresFlex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * User ID. + */ + userId: string; +} + +/** + * A collection of values returned by getPostgresflexUser. + */ +export interface GetPostgresflexUserResult { + readonly host: string; + readonly id: string; + /** + * ID of the PostgresFlex instance. + */ + readonly instanceId: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + readonly roles: string[]; + /** + * User ID. + */ + readonly userId: string; + readonly username: string; +} +/** + * Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPostgresflexUserOutput(args: GetPostgresflexUserOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getPostgresflexUser:getPostgresflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getPostgresflexUser. + */ +export interface GetPostgresflexUserOutputArgs { + /** + * ID of the PostgresFlex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * User ID. + */ + userId: pulumi.Input; +} diff --git a/sdk/nodejs/getPublicIp.ts b/sdk/nodejs/getPublicIp.ts new file mode 100644 index 0000000..08c261b --- /dev/null +++ b/sdk/nodejs/getPublicIp.ts @@ -0,0 +1,85 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Public IP resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPublicIp(args: GetPublicIpArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getPublicIp:getPublicIp", { + "projectId": args.projectId, + "publicIpId": args.publicIpId, + }, opts); +} + +/** + * A collection of arguments for invoking getPublicIp. + */ +export interface GetPublicIpArgs { + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId: string; + /** + * The public IP ID. + */ + publicIpId: string; +} + +/** + * A collection of values returned by getPublicIp. + */ +export interface GetPublicIpResult { + readonly id: string; + /** + * The IP address. + */ + readonly ip: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * Associates the public IP with a network interface or a virtual IP (ID). + */ + readonly networkInterfaceId: string; + /** + * STACKIT project ID to which the public IP is associated. + */ + readonly projectId: string; + /** + * The public IP ID. + */ + readonly publicIpId: string; +} +/** + * Public IP resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getPublicIpOutput(args: GetPublicIpOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getPublicIp:getPublicIp", { + "projectId": args.projectId, + "publicIpId": args.publicIpId, + }, opts); +} + +/** + * A collection of arguments for invoking getPublicIp. + */ +export interface GetPublicIpOutputArgs { + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId: pulumi.Input; + /** + * The public IP ID. + */ + publicIpId: pulumi.Input; +} diff --git a/sdk/nodejs/getPublicIpRanges.ts b/sdk/nodejs/getPublicIpRanges.ts new file mode 100644 index 0000000..f0a5132 --- /dev/null +++ b/sdk/nodejs/getPublicIpRanges.ts @@ -0,0 +1,39 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * A list of all public IP ranges that STACKIT uses. + * + * ## Example Usage + */ +export function getPublicIpRanges(opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getPublicIpRanges:getPublicIpRanges", { + }, opts); +} + +/** + * A collection of values returned by getPublicIpRanges. + */ +export interface GetPublicIpRangesResult { + readonly id: string; + /** + * A list of all public IP ranges. + */ + readonly publicIpRanges: outputs.GetPublicIpRangesPublicIpRange[]; +} +/** + * A list of all public IP ranges that STACKIT uses. + * + * ## Example Usage + */ +export function getPublicIpRangesOutput(opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getPublicIpRanges:getPublicIpRanges", { + }, opts); +} diff --git a/sdk/nodejs/getRabbitmqCredential.ts b/sdk/nodejs/getRabbitmqCredential.ts new file mode 100644 index 0000000..1fb4596 --- /dev/null +++ b/sdk/nodejs/getRabbitmqCredential.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRabbitmqCredential(args: GetRabbitmqCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getRabbitmqCredential:getRabbitmqCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRabbitmqCredential. + */ +export interface GetRabbitmqCredentialArgs { + /** + * The credential's ID. + */ + credentialId: string; + /** + * ID of the RabbitMQ instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getRabbitmqCredential. + */ +export interface GetRabbitmqCredentialResult { + /** + * The credential's ID. + */ + readonly credentialId: string; + readonly host: string; + readonly hosts: string[]; + readonly httpApiUri: string; + readonly httpApiUris: string[]; + readonly id: string; + /** + * ID of the RabbitMQ instance. + */ + readonly instanceId: string; + readonly management: string; + readonly password: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + readonly uri: string; + readonly uris: string[]; + readonly username: string; +} +/** + * RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRabbitmqCredentialOutput(args: GetRabbitmqCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getRabbitmqCredential:getRabbitmqCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRabbitmqCredential. + */ +export interface GetRabbitmqCredentialOutputArgs { + /** + * The credential's ID. + */ + credentialId: pulumi.Input; + /** + * ID of the RabbitMQ instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getRabbitmqInstance.ts b/sdk/nodejs/getRabbitmqInstance.ts new file mode 100644 index 0000000..796308a --- /dev/null +++ b/sdk/nodejs/getRabbitmqInstance.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRabbitmqInstance(args: GetRabbitmqInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getRabbitmqInstance:getRabbitmqInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRabbitmqInstance. + */ +export interface GetRabbitmqInstanceArgs { + /** + * ID of the RabbitMQ instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getRabbitmqInstance. + */ +export interface GetRabbitmqInstanceResult { + readonly cfGuid: string; + readonly cfOrganizationGuid: string; + readonly cfSpaceGuid: string; + readonly dashboardUrl: string; + readonly id: string; + readonly imageUrl: string; + /** + * ID of the RabbitMQ instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + readonly parameters: outputs.GetRabbitmqInstanceParameters; + /** + * The selected plan ID. + */ + readonly planId: string; + /** + * The selected plan name. + */ + readonly planName: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The service version. + */ + readonly version: string; +} +/** + * RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRabbitmqInstanceOutput(args: GetRabbitmqInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getRabbitmqInstance:getRabbitmqInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRabbitmqInstance. + */ +export interface GetRabbitmqInstanceOutputArgs { + /** + * ID of the RabbitMQ instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getRedisCredential.ts b/sdk/nodejs/getRedisCredential.ts new file mode 100644 index 0000000..f8c954e --- /dev/null +++ b/sdk/nodejs/getRedisCredential.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Redis credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRedisCredential(args: GetRedisCredentialArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getRedisCredential:getRedisCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRedisCredential. + */ +export interface GetRedisCredentialArgs { + /** + * The credential's ID. + */ + credentialId: string; + /** + * ID of the Redis instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getRedisCredential. + */ +export interface GetRedisCredentialResult { + /** + * The credential's ID. + */ + readonly credentialId: string; + readonly host: string; + readonly hosts: string[]; + readonly id: string; + /** + * ID of the Redis instance. + */ + readonly instanceId: string; + readonly loadBalancedHost: string; + readonly password: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * Connection URI. + */ + readonly uri: string; + readonly username: string; +} +/** + * Redis credential data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRedisCredentialOutput(args: GetRedisCredentialOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getRedisCredential:getRedisCredential", { + "credentialId": args.credentialId, + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRedisCredential. + */ +export interface GetRedisCredentialOutputArgs { + /** + * The credential's ID. + */ + credentialId: pulumi.Input; + /** + * ID of the Redis instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getRedisInstance.ts b/sdk/nodejs/getRedisInstance.ts new file mode 100644 index 0000000..629c5a4 --- /dev/null +++ b/sdk/nodejs/getRedisInstance.ts @@ -0,0 +1,97 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Redis instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRedisInstance(args: GetRedisInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getRedisInstance:getRedisInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRedisInstance. + */ +export interface GetRedisInstanceArgs { + /** + * ID of the Redis instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getRedisInstance. + */ +export interface GetRedisInstanceResult { + readonly cfGuid: string; + readonly cfOrganizationGuid: string; + readonly cfSpaceGuid: string; + readonly dashboardUrl: string; + readonly id: string; + readonly imageUrl: string; + /** + * ID of the Redis instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + readonly parameters: outputs.GetRedisInstanceParameters; + /** + * The selected plan ID. + */ + readonly planId: string; + /** + * The selected plan name. + */ + readonly planName: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The service version. + */ + readonly version: string; +} +/** + * Redis instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getRedisInstanceOutput(args: GetRedisInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getRedisInstance:getRedisInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getRedisInstance. + */ +export interface GetRedisInstanceOutputArgs { + /** + * ID of the Redis instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getResourcemanagerProject.ts b/sdk/nodejs/getResourcemanagerProject.ts new file mode 100644 index 0000000..cba043e --- /dev/null +++ b/sdk/nodejs/getResourcemanagerProject.ts @@ -0,0 +1,87 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Resource Manager project data source schema. To identify the project, you need to provider either projectId or container_id. If you provide both, projectId will be used. + * + * ## Example Usage + */ +export function getResourcemanagerProject(args?: GetResourcemanagerProjectArgs, opts?: pulumi.InvokeOptions): Promise { + args = args || {}; + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getResourcemanagerProject:getResourcemanagerProject", { + "containerId": args.containerId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getResourcemanagerProject. + */ +export interface GetResourcemanagerProjectArgs { + /** + * Project container ID. Globally unique, user-friendly identifier. + */ + containerId?: string; + /** + * Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + */ + projectId?: string; +} + +/** + * A collection of values returned by getResourcemanagerProject. + */ +export interface GetResourcemanagerProjectResult { + /** + * Project container ID. Globally unique, user-friendly identifier. + */ + readonly containerId?: string; + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64} + */ + readonly labels: {[key: string]: string}; + /** + * Project name. + */ + readonly name: string; + /** + * Parent resource identifier. Both container ID (user-friendly) and UUID are supported + */ + readonly parentContainerId: string; + /** + * Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + */ + readonly projectId?: string; +} +/** + * Resource Manager project data source schema. To identify the project, you need to provider either projectId or container_id. If you provide both, projectId will be used. + * + * ## Example Usage + */ +export function getResourcemanagerProjectOutput(args?: GetResourcemanagerProjectOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + args = args || {}; + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getResourcemanagerProject:getResourcemanagerProject", { + "containerId": args.containerId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getResourcemanagerProject. + */ +export interface GetResourcemanagerProjectOutputArgs { + /** + * Project container ID. Globally unique, user-friendly identifier. + */ + containerId?: pulumi.Input; + /** + * Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + */ + projectId?: pulumi.Input; +} diff --git a/sdk/nodejs/getSecretsmanagerInstance.ts b/sdk/nodejs/getSecretsmanagerInstance.ts new file mode 100644 index 0000000..82fc9af --- /dev/null +++ b/sdk/nodejs/getSecretsmanagerInstance.ts @@ -0,0 +1,81 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecretsmanagerInstance(args: GetSecretsmanagerInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecretsmanagerInstance. + */ +export interface GetSecretsmanagerInstanceArgs { + /** + * ID of the Secrets Manager instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getSecretsmanagerInstance. + */ +export interface GetSecretsmanagerInstanceResult { + /** + * The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + */ + readonly acls: string[]; + readonly id: string; + /** + * ID of the Secrets Manager instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; +} +/** + * Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecretsmanagerInstanceOutput(args: GetSecretsmanagerInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecretsmanagerInstance. + */ +export interface GetSecretsmanagerInstanceOutputArgs { + /** + * ID of the Secrets Manager instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getSecretsmanagerUser.ts b/sdk/nodejs/getSecretsmanagerUser.ts new file mode 100644 index 0000000..845183e --- /dev/null +++ b/sdk/nodejs/getSecretsmanagerUser.ts @@ -0,0 +1,99 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecretsmanagerUser(args: GetSecretsmanagerUserArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecretsmanagerUser. + */ +export interface GetSecretsmanagerUserArgs { + /** + * ID of the Secrets Manager instance. + */ + instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: string; + /** + * The user's ID. + */ + userId: string; +} + +/** + * A collection of values returned by getSecretsmanagerUser. + */ +export interface GetSecretsmanagerUserResult { + /** + * A user chosen description to differentiate between multiple users. Can't be changed after creation. + */ + readonly description: string; + readonly id: string; + /** + * ID of the Secrets Manager instance. + */ + readonly instanceId: string; + /** + * STACKIT Project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The user's ID. + */ + readonly userId: string; + /** + * An auto-generated user name. + */ + readonly username: string; + /** + * If true, the user has writeaccess to the secrets engine. + */ + readonly writeEnabled: boolean; +} +/** + * Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecretsmanagerUserOutput(args: GetSecretsmanagerUserOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSecretsmanagerUser:getSecretsmanagerUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecretsmanagerUser. + */ +export interface GetSecretsmanagerUserOutputArgs { + /** + * ID of the Secrets Manager instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The user's ID. + */ + userId: pulumi.Input; +} diff --git a/sdk/nodejs/getSecurityGroup.ts b/sdk/nodejs/getSecurityGroup.ts new file mode 100644 index 0000000..80642a5 --- /dev/null +++ b/sdk/nodejs/getSecurityGroup.ts @@ -0,0 +1,89 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Security group datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecurityGroup(args: GetSecurityGroupArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSecurityGroup:getSecurityGroup", { + "projectId": args.projectId, + "securityGroupId": args.securityGroupId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecurityGroup. + */ +export interface GetSecurityGroupArgs { + /** + * STACKIT project ID to which the security group is associated. + */ + projectId: string; + /** + * The security group ID. + */ + securityGroupId: string; +} + +/** + * A collection of values returned by getSecurityGroup. + */ +export interface GetSecurityGroupResult { + /** + * The description of the security group. + */ + readonly description: string; + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The name of the security group. + */ + readonly name: string; + /** + * STACKIT project ID to which the security group is associated. + */ + readonly projectId: string; + /** + * The security group ID. + */ + readonly securityGroupId: string; + /** + * Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + */ + readonly stateful: boolean; +} +/** + * Security group datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecurityGroupOutput(args: GetSecurityGroupOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSecurityGroup:getSecurityGroup", { + "projectId": args.projectId, + "securityGroupId": args.securityGroupId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecurityGroup. + */ +export interface GetSecurityGroupOutputArgs { + /** + * STACKIT project ID to which the security group is associated. + */ + projectId: pulumi.Input; + /** + * The security group ID. + */ + securityGroupId: pulumi.Input; +} diff --git a/sdk/nodejs/getSecurityGroupRule.ts b/sdk/nodejs/getSecurityGroupRule.ts new file mode 100644 index 0000000..4e96a09 --- /dev/null +++ b/sdk/nodejs/getSecurityGroupRule.ts @@ -0,0 +1,121 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Security group datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecurityGroupRule(args: GetSecurityGroupRuleArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSecurityGroupRule:getSecurityGroupRule", { + "projectId": args.projectId, + "securityGroupId": args.securityGroupId, + "securityGroupRuleId": args.securityGroupRuleId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecurityGroupRule. + */ +export interface GetSecurityGroupRuleArgs { + /** + * STACKIT project ID to which the security group rule is associated. + */ + projectId: string; + /** + * The security group ID. + */ + securityGroupId: string; + /** + * The security group rule ID. + */ + securityGroupRuleId: string; +} + +/** + * A collection of values returned by getSecurityGroupRule. + */ +export interface GetSecurityGroupRuleResult { + /** + * The description of the security group rule. + */ + readonly description: string; + /** + * The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + */ + readonly direction: string; + /** + * The ethertype which the rule should match. + */ + readonly etherType: string; + /** + * ICMP Parameters. + */ + readonly icmpParameters: outputs.GetSecurityGroupRuleIcmpParameters; + readonly id: string; + /** + * The remote IP range which the rule should match. + */ + readonly ipRange: string; + /** + * The range of ports. + */ + readonly portRange: outputs.GetSecurityGroupRulePortRange; + /** + * STACKIT project ID to which the security group rule is associated. + */ + readonly projectId: string; + /** + * The internet protocol which the rule should match. + */ + readonly protocol: outputs.GetSecurityGroupRuleProtocol; + /** + * The remote security group which the rule should match. + */ + readonly remoteSecurityGroupId: string; + /** + * The security group ID. + */ + readonly securityGroupId: string; + /** + * The security group rule ID. + */ + readonly securityGroupRuleId: string; +} +/** + * Security group datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSecurityGroupRuleOutput(args: GetSecurityGroupRuleOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSecurityGroupRule:getSecurityGroupRule", { + "projectId": args.projectId, + "securityGroupId": args.securityGroupId, + "securityGroupRuleId": args.securityGroupRuleId, + }, opts); +} + +/** + * A collection of arguments for invoking getSecurityGroupRule. + */ +export interface GetSecurityGroupRuleOutputArgs { + /** + * STACKIT project ID to which the security group rule is associated. + */ + projectId: pulumi.Input; + /** + * The security group ID. + */ + securityGroupId: pulumi.Input; + /** + * The security group rule ID. + */ + securityGroupRuleId: pulumi.Input; +} diff --git a/sdk/nodejs/getServer.ts b/sdk/nodejs/getServer.ts new file mode 100644 index 0000000..23c3138 --- /dev/null +++ b/sdk/nodejs/getServer.ts @@ -0,0 +1,127 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getServer(args: GetServerArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServer:getServer", { + "projectId": args.projectId, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServer. + */ +export interface GetServerArgs { + /** + * STACKIT project ID to which the server is associated. + */ + projectId: string; + /** + * The server ID. + */ + serverId: string; +} + +/** + * A collection of values returned by getServer. + */ +export interface GetServerResult { + /** + * The affinity group the server is assigned to. + */ + readonly affinityGroup: string; + /** + * The availability zone of the server. + */ + readonly availabilityZone: string; + /** + * The boot volume for the server + */ + readonly bootVolume: outputs.GetServerBootVolume; + /** + * Date-time when the server was created + */ + readonly createdAt: string; + readonly id: string; + /** + * The image ID to be used for an ephemeral disk on the server. + */ + readonly imageId: string; + /** + * The name of the keypair used during server creation. + */ + readonly keypairName: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * Date-time when the server was launched + */ + readonly launchedAt: string; + /** + * Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + */ + readonly machineType: string; + /** + * The name of the server. + */ + readonly name: string; + /** + * The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + */ + readonly networkInterfaces: string[]; + /** + * STACKIT project ID to which the server is associated. + */ + readonly projectId: string; + /** + * The server ID. + */ + readonly serverId: string; + /** + * Date-time when the server was updated + */ + readonly updatedAt: string; + /** + * User data that is passed via cloud-init to the server. + */ + readonly userData: string; +} +/** + * Server datasource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getServerOutput(args: GetServerOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServer:getServer", { + "projectId": args.projectId, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServer. + */ +export interface GetServerOutputArgs { + /** + * STACKIT project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The server ID. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/getServerBackupSchedule.ts b/sdk/nodejs/getServerBackupSchedule.ts new file mode 100644 index 0000000..73df37b --- /dev/null +++ b/sdk/nodejs/getServerBackupSchedule.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerBackupSchedule(args: GetServerBackupScheduleArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServerBackupSchedule:getServerBackupSchedule", { + "backupScheduleId": args.backupScheduleId, + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerBackupSchedule. + */ +export interface GetServerBackupScheduleArgs { + /** + * Backup schedule ID. + */ + backupScheduleId: number; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * Server ID for the backup schedule. + */ + serverId: string; +} + +/** + * A collection of values returned by getServerBackupSchedule. + */ +export interface GetServerBackupScheduleResult { + /** + * Backup schedule details for the backups. + */ + readonly backupProperties: outputs.GetServerBackupScheduleBackupProperties; + /** + * Backup schedule ID. + */ + readonly backupScheduleId: number; + /** + * Is the backup schedule enabled or disabled. + */ + readonly enabled: boolean; + readonly id: string; + /** + * The schedule name. + */ + readonly name: string; + /** + * STACKIT Project ID to which the server is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Backup schedule described in `rrule` (recurrence rule) format. + */ + readonly rrule: string; + /** + * Server ID for the backup schedule. + */ + readonly serverId: string; +} +/** + * Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerBackupScheduleOutput(args: GetServerBackupScheduleOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServerBackupSchedule:getServerBackupSchedule", { + "backupScheduleId": args.backupScheduleId, + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerBackupSchedule. + */ +export interface GetServerBackupScheduleOutputArgs { + /** + * Backup schedule ID. + */ + backupScheduleId: pulumi.Input; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Server ID for the backup schedule. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/getServerBackupSchedules.ts b/sdk/nodejs/getServerBackupSchedules.ts new file mode 100644 index 0000000..ed623d1 --- /dev/null +++ b/sdk/nodejs/getServerBackupSchedules.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerBackupSchedules(args: GetServerBackupSchedulesArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServerBackupSchedules:getServerBackupSchedules", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerBackupSchedules. + */ +export interface GetServerBackupSchedulesArgs { + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * Server ID (UUID) to which the backup schedule is associated. + */ + serverId: string; +} + +/** + * A collection of values returned by getServerBackupSchedules. + */ +export interface GetServerBackupSchedulesResult { + readonly id: string; + readonly items: outputs.GetServerBackupSchedulesItem[]; + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Server ID (UUID) to which the backup schedule is associated. + */ + readonly serverId: string; +} +/** + * Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerBackupSchedulesOutput(args: GetServerBackupSchedulesOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServerBackupSchedules:getServerBackupSchedules", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerBackupSchedules. + */ +export interface GetServerBackupSchedulesOutputArgs { + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Server ID (UUID) to which the backup schedule is associated. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/getServerUpdateSchedule.ts b/sdk/nodejs/getServerUpdateSchedule.ts new file mode 100644 index 0000000..faae4c7 --- /dev/null +++ b/sdk/nodejs/getServerUpdateSchedule.ts @@ -0,0 +1,121 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerUpdateSchedule(args: GetServerUpdateScheduleArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + "updateScheduleId": args.updateScheduleId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerUpdateSchedule. + */ +export interface GetServerUpdateScheduleArgs { + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * Server ID for the update schedule. + */ + serverId: string; + /** + * Update schedule ID. + */ + updateScheduleId: number; +} + +/** + * A collection of values returned by getServerUpdateSchedule. + */ +export interface GetServerUpdateScheduleResult { + /** + * Is the update schedule enabled or disabled. + */ + readonly enabled: boolean; + readonly id: string; + /** + * Maintenance window [1..24]. + */ + readonly maintenanceWindow: number; + /** + * The schedule name. + */ + readonly name: string; + /** + * STACKIT Project ID to which the server is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Update schedule described in `rrule` (recurrence rule) format. + */ + readonly rrule: string; + /** + * Server ID for the update schedule. + */ + readonly serverId: string; + /** + * Update schedule ID. + */ + readonly updateScheduleId: number; +} +/** + * Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerUpdateScheduleOutput(args: GetServerUpdateScheduleOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServerUpdateSchedule:getServerUpdateSchedule", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + "updateScheduleId": args.updateScheduleId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerUpdateSchedule. + */ +export interface GetServerUpdateScheduleOutputArgs { + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Server ID for the update schedule. + */ + serverId: pulumi.Input; + /** + * Update schedule ID. + */ + updateScheduleId: pulumi.Input; +} diff --git a/sdk/nodejs/getServerUpdateSchedules.ts b/sdk/nodejs/getServerUpdateSchedules.ts new file mode 100644 index 0000000..8abcef2 --- /dev/null +++ b/sdk/nodejs/getServerUpdateSchedules.ts @@ -0,0 +1,94 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerUpdateSchedules(args: GetServerUpdateSchedulesArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerUpdateSchedules. + */ +export interface GetServerUpdateSchedulesArgs { + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * Server ID (UUID) to which the update schedule is associated. + */ + serverId: string; +} + +/** + * A collection of values returned by getServerUpdateSchedules. + */ +export interface GetServerUpdateSchedulesResult { + readonly id: string; + readonly items: outputs.GetServerUpdateSchedulesItem[]; + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Server ID (UUID) to which the update schedule is associated. + */ + readonly serverId: string; +} +/** + * Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export function getServerUpdateSchedulesOutput(args: GetServerUpdateSchedulesOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServerUpdateSchedules:getServerUpdateSchedules", { + "projectId": args.projectId, + "region": args.region, + "serverId": args.serverId, + }, opts); +} + +/** + * A collection of arguments for invoking getServerUpdateSchedules. + */ +export interface GetServerUpdateSchedulesOutputArgs { + /** + * STACKIT Project ID (UUID) to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Server ID (UUID) to which the update schedule is associated. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/getServiceAccount.ts b/sdk/nodejs/getServiceAccount.ts new file mode 100644 index 0000000..0b4bb98 --- /dev/null +++ b/sdk/nodejs/getServiceAccount.ts @@ -0,0 +1,77 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Service account data source schema. + * + * ## Example Usage + */ +export function getServiceAccount(args: GetServiceAccountArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getServiceAccount:getServiceAccount", { + "email": args.email, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getServiceAccount. + */ +export interface GetServiceAccountArgs { + /** + * Email of the service account. + */ + email: string; + /** + * STACKIT project ID to which the service account is associated. + */ + projectId: string; +} + +/** + * A collection of values returned by getServiceAccount. + */ +export interface GetServiceAccountResult { + /** + * Email of the service account. + */ + readonly email: string; + readonly id: string; + /** + * Name of the service account. + */ + readonly name: string; + /** + * STACKIT project ID to which the service account is associated. + */ + readonly projectId: string; +} +/** + * Service account data source schema. + * + * ## Example Usage + */ +export function getServiceAccountOutput(args: GetServiceAccountOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getServiceAccount:getServiceAccount", { + "email": args.email, + "projectId": args.projectId, + }, opts); +} + +/** + * A collection of arguments for invoking getServiceAccount. + */ +export interface GetServiceAccountOutputArgs { + /** + * Email of the service account. + */ + email: pulumi.Input; + /** + * STACKIT project ID to which the service account is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/getSkeCluster.ts b/sdk/nodejs/getSkeCluster.ts new file mode 100644 index 0000000..302bb78 --- /dev/null +++ b/sdk/nodejs/getSkeCluster.ts @@ -0,0 +1,135 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSkeCluster(args: GetSkeClusterArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSkeCluster:getSkeCluster", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getSkeCluster. + */ +export interface GetSkeClusterArgs { + /** + * The cluster name. + */ + name: string; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getSkeCluster. + */ +export interface GetSkeClusterResult { + /** + * DEPRECATED as of Kubernetes 1.25+ + * Flag to specify if privileged mode for containers is enabled or not. + * This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + * + * @deprecated Please remove this flag from your configuration when using Kubernetes version 1.25+. + */ + readonly allowPrivilegedContainers: boolean; + /** + * The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + */ + readonly egressAddressRanges: string[]; + /** + * A single extensions block as defined below + */ + readonly extensions: outputs.GetSkeClusterExtensions; + /** + * One or more hibernation block as defined below. + */ + readonly hibernations: outputs.GetSkeClusterHibernation[]; + readonly id: string; + /** + * Kubernetes version. This field is deprecated, use `kubernetesVersionUsed` instead + * + * @deprecated This field is always nil, use `kubernetesVersionUsed` to get the cluster kubernetes version. This field would cause errors when the cluster got a kubernetes version minor upgrade, either triggered by automatic or forceful updates. + */ + readonly kubernetesVersion: string; + /** + * The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetesVersionUsed` field. + */ + readonly kubernetesVersionMin: string; + /** + * Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15` + */ + readonly kubernetesVersionUsed: string; + /** + * A single maintenance block as defined below + */ + readonly maintenance: outputs.GetSkeClusterMaintenance; + /** + * The cluster name. + */ + readonly name: string; + /** + * Network block as defined below. + */ + readonly network: outputs.GetSkeClusterNetwork; + /** + * One or more `nodePool` block as defined below. + */ + readonly nodePools: outputs.GetSkeClusterNodePool[]; + /** + * STACKIT project ID to which the cluster is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; +} +/** + * SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSkeClusterOutput(args: GetSkeClusterOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSkeCluster:getSkeCluster", { + "name": args.name, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getSkeCluster. + */ +export interface GetSkeClusterOutputArgs { + /** + * The cluster name. + */ + name: pulumi.Input; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getSqlserverflexInstance.ts b/sdk/nodejs/getSqlserverflexInstance.ts new file mode 100644 index 0000000..bab0424 --- /dev/null +++ b/sdk/nodejs/getSqlserverflexInstance.ts @@ -0,0 +1,109 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSqlserverflexInstance(args: GetSqlserverflexInstanceArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getSqlserverflexInstance. + */ +export interface GetSqlserverflexInstanceArgs { + /** + * ID of the SQLServer Flex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; +} + +/** + * A collection of values returned by getSqlserverflexInstance. + */ +export interface GetSqlserverflexInstanceResult { + /** + * The Access Control List (ACL) for the SQLServer Flex instance. + */ + readonly acls: string[]; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + */ + readonly backupSchedule: string; + readonly flavor: outputs.GetSqlserverflexInstanceFlavor; + readonly id: string; + /** + * ID of the SQLServer Flex instance. + */ + readonly instanceId: string; + /** + * Instance name. + */ + readonly name: string; + /** + * Custom parameters for the SQLServer Flex instance. + */ + readonly options: outputs.GetSqlserverflexInstanceOptions; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + readonly replicas: number; + readonly storage: outputs.GetSqlserverflexInstanceStorage; + readonly version: string; +} +/** + * SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSqlserverflexInstanceOutput(args: GetSqlserverflexInstanceOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSqlserverflexInstance:getSqlserverflexInstance", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + }, opts); +} + +/** + * A collection of arguments for invoking getSqlserverflexInstance. + */ +export interface GetSqlserverflexInstanceOutputArgs { + /** + * ID of the SQLServer Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/getSqlserverflexUser.ts b/sdk/nodejs/getSqlserverflexUser.ts new file mode 100644 index 0000000..6061322 --- /dev/null +++ b/sdk/nodejs/getSqlserverflexUser.ts @@ -0,0 +1,111 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSqlserverflexUser(args: GetSqlserverflexUserArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getSqlserverflexUser:getSqlserverflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getSqlserverflexUser. + */ +export interface GetSqlserverflexUserArgs { + /** + * ID of the SQLServer Flex instance. + */ + instanceId: string; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: string; + /** + * User ID. + */ + userId: string; +} + +/** + * A collection of values returned by getSqlserverflexUser. + */ +export interface GetSqlserverflexUserResult { + readonly host: string; + readonly id: string; + /** + * ID of the SQLServer Flex instance. + */ + readonly instanceId: string; + readonly port: number; + /** + * STACKIT project ID to which the instance is associated. + */ + readonly projectId: string; + /** + * The resource region. If not defined, the provider region is used. + */ + readonly region?: string; + /** + * Database access levels for the user. + */ + readonly roles: string[]; + /** + * User ID. + */ + readonly userId: string; + /** + * Username of the SQLServer Flex instance. + */ + readonly username: string; +} +/** + * SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getSqlserverflexUserOutput(args: GetSqlserverflexUserOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getSqlserverflexUser:getSqlserverflexUser", { + "instanceId": args.instanceId, + "projectId": args.projectId, + "region": args.region, + "userId": args.userId, + }, opts); +} + +/** + * A collection of arguments for invoking getSqlserverflexUser. + */ +export interface GetSqlserverflexUserOutputArgs { + /** + * ID of the SQLServer Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * User ID. + */ + userId: pulumi.Input; +} diff --git a/sdk/nodejs/getVolume.ts b/sdk/nodejs/getVolume.ts new file mode 100644 index 0000000..83d9b93 --- /dev/null +++ b/sdk/nodejs/getVolume.ts @@ -0,0 +1,107 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Volume resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getVolume(args: GetVolumeArgs, opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("stackit:index/getVolume:getVolume", { + "projectId": args.projectId, + "volumeId": args.volumeId, + }, opts); +} + +/** + * A collection of arguments for invoking getVolume. + */ +export interface GetVolumeArgs { + /** + * STACKIT project ID to which the volume is associated. + */ + projectId: string; + /** + * The volume ID. + */ + volumeId: string; +} + +/** + * A collection of values returned by getVolume. + */ +export interface GetVolumeResult { + /** + * The availability zone of the volume. + */ + readonly availabilityZone: string; + /** + * The description of the volume. + */ + readonly description: string; + readonly id: string; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + readonly labels: {[key: string]: string}; + /** + * The name of the volume. + */ + readonly name: string; + /** + * The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + */ + readonly performanceClass: string; + /** + * STACKIT project ID to which the volume is associated. + */ + readonly projectId: string; + /** + * The server ID of the server to which the volume is attached to. + */ + readonly serverId: string; + /** + * The size of the volume in GB. It can only be updated to a larger value than the current size + */ + readonly size: number; + /** + * The source of the volume. It can be either a volume, an image, a snapshot or a backup + */ + readonly source: outputs.GetVolumeSource; + /** + * The volume ID. + */ + readonly volumeId: string; +} +/** + * Volume resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export function getVolumeOutput(args: GetVolumeOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("stackit:index/getVolume:getVolume", { + "projectId": args.projectId, + "volumeId": args.volumeId, + }, opts); +} + +/** + * A collection of arguments for invoking getVolume. + */ +export interface GetVolumeOutputArgs { + /** + * STACKIT project ID to which the volume is associated. + */ + projectId: pulumi.Input; + /** + * The volume ID. + */ + volumeId: pulumi.Input; +} diff --git a/sdk/nodejs/git.ts b/sdk/nodejs/git.ts new file mode 100644 index 0000000..65e9120 --- /dev/null +++ b/sdk/nodejs/git.ts @@ -0,0 +1,135 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Git Instance resource schema. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export class Git extends pulumi.CustomResource { + /** + * Get an existing Git 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?: GitState, opts?: pulumi.CustomResourceOptions): Git { + return new Git(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/git:Git'; + + /** + * Returns true if the given object is an instance of Git. 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 Git { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Git.__pulumiType; + } + + /** + * ID linked to the git instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Unique name linked to the git instance. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the git instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Url linked to the git instance. + */ + public /*out*/ readonly url!: pulumi.Output; + /** + * Version linked to the git instance. + */ + public /*out*/ readonly version!: pulumi.Output; + + /** + * Create a Git 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: GitArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: GitArgs | GitState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as GitState | undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["url"] = state ? state.url : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as GitArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["url"] = undefined /*out*/; + resourceInputs["version"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Git.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Git resources. + */ +export interface GitState { + /** + * ID linked to the git instance. + */ + instanceId?: pulumi.Input; + /** + * Unique name linked to the git instance. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the git instance is associated. + */ + projectId?: pulumi.Input; + /** + * Url linked to the git instance. + */ + url?: pulumi.Input; + /** + * Version linked to the git instance. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Git resource. + */ +export interface GitArgs { + /** + * Unique name linked to the git instance. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the git instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/image.ts b/sdk/nodejs/image.ts new file mode 100644 index 0000000..def4ccb --- /dev/null +++ b/sdk/nodejs/image.ts @@ -0,0 +1,235 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Image resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class Image extends pulumi.CustomResource { + /** + * Get an existing Image 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?: ImageState, opts?: pulumi.CustomResourceOptions): Image { + return new Image(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/image:Image'; + + /** + * Returns true if the given object is an instance of Image. 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 Image { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Image.__pulumiType; + } + + /** + * Representation of an image checksum. + */ + public /*out*/ readonly checksum!: pulumi.Output; + /** + * Properties to set hardware and scheduling settings for an image. + */ + public readonly config!: pulumi.Output; + /** + * The disk format of the image. + */ + public readonly diskFormat!: pulumi.Output; + /** + * The image ID. + */ + public /*out*/ readonly imageId!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The filepath of the raw image file to be uploaded. + */ + public readonly localFilePath!: pulumi.Output; + /** + * The minimum disk size of the image in GB. + */ + public readonly minDiskSize!: pulumi.Output; + /** + * The minimum RAM of the image in MB. + */ + public readonly minRam!: pulumi.Output; + /** + * The name of the image. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the image is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Whether the image is protected. + */ + public /*out*/ readonly protected!: pulumi.Output; + /** + * The scope of the image. + */ + public /*out*/ readonly scope!: pulumi.Output; + + /** + * Create a Image 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: ImageArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ImageArgs | ImageState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ImageState | undefined; + resourceInputs["checksum"] = state ? state.checksum : undefined; + resourceInputs["config"] = state ? state.config : undefined; + resourceInputs["diskFormat"] = state ? state.diskFormat : undefined; + resourceInputs["imageId"] = state ? state.imageId : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["localFilePath"] = state ? state.localFilePath : undefined; + resourceInputs["minDiskSize"] = state ? state.minDiskSize : undefined; + resourceInputs["minRam"] = state ? state.minRam : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["protected"] = state ? state.protected : undefined; + resourceInputs["scope"] = state ? state.scope : undefined; + } else { + const args = argsOrState as ImageArgs | undefined; + if ((!args || args.diskFormat === undefined) && !opts.urn) { + throw new Error("Missing required property 'diskFormat'"); + } + if ((!args || args.localFilePath === undefined) && !opts.urn) { + throw new Error("Missing required property 'localFilePath'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["config"] = args ? args.config : undefined; + resourceInputs["diskFormat"] = args ? args.diskFormat : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["localFilePath"] = args ? args.localFilePath : undefined; + resourceInputs["minDiskSize"] = args ? args.minDiskSize : undefined; + resourceInputs["minRam"] = args ? args.minRam : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["checksum"] = undefined /*out*/; + resourceInputs["imageId"] = undefined /*out*/; + resourceInputs["protected"] = undefined /*out*/; + resourceInputs["scope"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Image.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Image resources. + */ +export interface ImageState { + /** + * Representation of an image checksum. + */ + checksum?: pulumi.Input; + /** + * Properties to set hardware and scheduling settings for an image. + */ + config?: pulumi.Input; + /** + * The disk format of the image. + */ + diskFormat?: pulumi.Input; + /** + * The image ID. + */ + imageId?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The filepath of the raw image file to be uploaded. + */ + localFilePath?: pulumi.Input; + /** + * The minimum disk size of the image in GB. + */ + minDiskSize?: pulumi.Input; + /** + * The minimum RAM of the image in MB. + */ + minRam?: pulumi.Input; + /** + * The name of the image. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the image is associated. + */ + projectId?: pulumi.Input; + /** + * Whether the image is protected. + */ + protected?: pulumi.Input; + /** + * The scope of the image. + */ + scope?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Image resource. + */ +export interface ImageArgs { + /** + * Properties to set hardware and scheduling settings for an image. + */ + config?: pulumi.Input; + /** + * The disk format of the image. + */ + diskFormat: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The filepath of the raw image file to be uploaded. + */ + localFilePath: pulumi.Input; + /** + * The minimum disk size of the image in GB. + */ + minDiskSize?: pulumi.Input; + /** + * The minimum RAM of the image in MB. + */ + minRam?: pulumi.Input; + /** + * The name of the image. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the image is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/index.ts b/sdk/nodejs/index.ts new file mode 100644 index 0000000..7e62a44 --- /dev/null +++ b/sdk/nodejs/index.ts @@ -0,0 +1,786 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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 members: +export { AffinityGroupArgs, AffinityGroupState } from "./affinityGroup"; +export type AffinityGroup = import("./affinityGroup").AffinityGroup; +export const AffinityGroup: typeof import("./affinityGroup").AffinityGroup = null as any; +utilities.lazyLoad(exports, ["AffinityGroup"], () => require("./affinityGroup")); + +export { AuthorizationOrganizationRoleAssignmentArgs, AuthorizationOrganizationRoleAssignmentState } from "./authorizationOrganizationRoleAssignment"; +export type AuthorizationOrganizationRoleAssignment = import("./authorizationOrganizationRoleAssignment").AuthorizationOrganizationRoleAssignment; +export const AuthorizationOrganizationRoleAssignment: typeof import("./authorizationOrganizationRoleAssignment").AuthorizationOrganizationRoleAssignment = null as any; +utilities.lazyLoad(exports, ["AuthorizationOrganizationRoleAssignment"], () => require("./authorizationOrganizationRoleAssignment")); + +export { AuthorizationProjectRoleAssignmentArgs, AuthorizationProjectRoleAssignmentState } from "./authorizationProjectRoleAssignment"; +export type AuthorizationProjectRoleAssignment = import("./authorizationProjectRoleAssignment").AuthorizationProjectRoleAssignment; +export const AuthorizationProjectRoleAssignment: typeof import("./authorizationProjectRoleAssignment").AuthorizationProjectRoleAssignment = null as any; +utilities.lazyLoad(exports, ["AuthorizationProjectRoleAssignment"], () => require("./authorizationProjectRoleAssignment")); + +export { CdnCustomDomainArgs, CdnCustomDomainState } from "./cdnCustomDomain"; +export type CdnCustomDomain = import("./cdnCustomDomain").CdnCustomDomain; +export const CdnCustomDomain: typeof import("./cdnCustomDomain").CdnCustomDomain = null as any; +utilities.lazyLoad(exports, ["CdnCustomDomain"], () => require("./cdnCustomDomain")); + +export { CdnDistributionArgs, CdnDistributionState } from "./cdnDistribution"; +export type CdnDistribution = import("./cdnDistribution").CdnDistribution; +export const CdnDistribution: typeof import("./cdnDistribution").CdnDistribution = null as any; +utilities.lazyLoad(exports, ["CdnDistribution"], () => require("./cdnDistribution")); + +export { DnsRecordSetArgs, DnsRecordSetState } from "./dnsRecordSet"; +export type DnsRecordSet = import("./dnsRecordSet").DnsRecordSet; +export const DnsRecordSet: typeof import("./dnsRecordSet").DnsRecordSet = null as any; +utilities.lazyLoad(exports, ["DnsRecordSet"], () => require("./dnsRecordSet")); + +export { DnsZoneArgs, DnsZoneState } from "./dnsZone"; +export type DnsZone = import("./dnsZone").DnsZone; +export const DnsZone: typeof import("./dnsZone").DnsZone = null as any; +utilities.lazyLoad(exports, ["DnsZone"], () => require("./dnsZone")); + +export { GetAffinityGroupArgs, GetAffinityGroupResult, GetAffinityGroupOutputArgs } from "./getAffinityGroup"; +export const getAffinityGroup: typeof import("./getAffinityGroup").getAffinityGroup = null as any; +export const getAffinityGroupOutput: typeof import("./getAffinityGroup").getAffinityGroupOutput = null as any; +utilities.lazyLoad(exports, ["getAffinityGroup","getAffinityGroupOutput"], () => require("./getAffinityGroup")); + +export { GetCdnCustomDomainArgs, GetCdnCustomDomainResult, GetCdnCustomDomainOutputArgs } from "./getCdnCustomDomain"; +export const getCdnCustomDomain: typeof import("./getCdnCustomDomain").getCdnCustomDomain = null as any; +export const getCdnCustomDomainOutput: typeof import("./getCdnCustomDomain").getCdnCustomDomainOutput = null as any; +utilities.lazyLoad(exports, ["getCdnCustomDomain","getCdnCustomDomainOutput"], () => require("./getCdnCustomDomain")); + +export { GetCdnDistributionArgs, GetCdnDistributionResult, GetCdnDistributionOutputArgs } from "./getCdnDistribution"; +export const getCdnDistribution: typeof import("./getCdnDistribution").getCdnDistribution = null as any; +export const getCdnDistributionOutput: typeof import("./getCdnDistribution").getCdnDistributionOutput = null as any; +utilities.lazyLoad(exports, ["getCdnDistribution","getCdnDistributionOutput"], () => require("./getCdnDistribution")); + +export { GetDnsRecordSetArgs, GetDnsRecordSetResult, GetDnsRecordSetOutputArgs } from "./getDnsRecordSet"; +export const getDnsRecordSet: typeof import("./getDnsRecordSet").getDnsRecordSet = null as any; +export const getDnsRecordSetOutput: typeof import("./getDnsRecordSet").getDnsRecordSetOutput = null as any; +utilities.lazyLoad(exports, ["getDnsRecordSet","getDnsRecordSetOutput"], () => require("./getDnsRecordSet")); + +export { GetDnsZoneArgs, GetDnsZoneResult, GetDnsZoneOutputArgs } from "./getDnsZone"; +export const getDnsZone: typeof import("./getDnsZone").getDnsZone = null as any; +export const getDnsZoneOutput: typeof import("./getDnsZone").getDnsZoneOutput = null as any; +utilities.lazyLoad(exports, ["getDnsZone","getDnsZoneOutput"], () => require("./getDnsZone")); + +export { GetGitArgs, GetGitResult, GetGitOutputArgs } from "./getGit"; +export const getGit: typeof import("./getGit").getGit = null as any; +export const getGitOutput: typeof import("./getGit").getGitOutput = null as any; +utilities.lazyLoad(exports, ["getGit","getGitOutput"], () => require("./getGit")); + +export { GetImageArgs, GetImageResult, GetImageOutputArgs } from "./getImage"; +export const getImage: typeof import("./getImage").getImage = null as any; +export const getImageOutput: typeof import("./getImage").getImageOutput = null as any; +utilities.lazyLoad(exports, ["getImage","getImageOutput"], () => require("./getImage")); + +export { GetKeyPairArgs, GetKeyPairResult, GetKeyPairOutputArgs } from "./getKeyPair"; +export const getKeyPair: typeof import("./getKeyPair").getKeyPair = null as any; +export const getKeyPairOutput: typeof import("./getKeyPair").getKeyPairOutput = null as any; +utilities.lazyLoad(exports, ["getKeyPair","getKeyPairOutput"], () => require("./getKeyPair")); + +export { GetLoadbalancerArgs, GetLoadbalancerResult, GetLoadbalancerOutputArgs } from "./getLoadbalancer"; +export const getLoadbalancer: typeof import("./getLoadbalancer").getLoadbalancer = null as any; +export const getLoadbalancerOutput: typeof import("./getLoadbalancer").getLoadbalancerOutput = null as any; +utilities.lazyLoad(exports, ["getLoadbalancer","getLoadbalancerOutput"], () => require("./getLoadbalancer")); + +export { GetLogmeCredentialArgs, GetLogmeCredentialResult, GetLogmeCredentialOutputArgs } from "./getLogmeCredential"; +export const getLogmeCredential: typeof import("./getLogmeCredential").getLogmeCredential = null as any; +export const getLogmeCredentialOutput: typeof import("./getLogmeCredential").getLogmeCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getLogmeCredential","getLogmeCredentialOutput"], () => require("./getLogmeCredential")); + +export { GetLogmeInstanceArgs, GetLogmeInstanceResult, GetLogmeInstanceOutputArgs } from "./getLogmeInstance"; +export const getLogmeInstance: typeof import("./getLogmeInstance").getLogmeInstance = null as any; +export const getLogmeInstanceOutput: typeof import("./getLogmeInstance").getLogmeInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getLogmeInstance","getLogmeInstanceOutput"], () => require("./getLogmeInstance")); + +export { GetMariadbCredentialArgs, GetMariadbCredentialResult, GetMariadbCredentialOutputArgs } from "./getMariadbCredential"; +export const getMariadbCredential: typeof import("./getMariadbCredential").getMariadbCredential = null as any; +export const getMariadbCredentialOutput: typeof import("./getMariadbCredential").getMariadbCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getMariadbCredential","getMariadbCredentialOutput"], () => require("./getMariadbCredential")); + +export { GetMariadbInstanceArgs, GetMariadbInstanceResult, GetMariadbInstanceOutputArgs } from "./getMariadbInstance"; +export const getMariadbInstance: typeof import("./getMariadbInstance").getMariadbInstance = null as any; +export const getMariadbInstanceOutput: typeof import("./getMariadbInstance").getMariadbInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getMariadbInstance","getMariadbInstanceOutput"], () => require("./getMariadbInstance")); + +export { GetMongodbflexInstanceArgs, GetMongodbflexInstanceResult, GetMongodbflexInstanceOutputArgs } from "./getMongodbflexInstance"; +export const getMongodbflexInstance: typeof import("./getMongodbflexInstance").getMongodbflexInstance = null as any; +export const getMongodbflexInstanceOutput: typeof import("./getMongodbflexInstance").getMongodbflexInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getMongodbflexInstance","getMongodbflexInstanceOutput"], () => require("./getMongodbflexInstance")); + +export { GetMongodbflexUserArgs, GetMongodbflexUserResult, GetMongodbflexUserOutputArgs } from "./getMongodbflexUser"; +export const getMongodbflexUser: typeof import("./getMongodbflexUser").getMongodbflexUser = null as any; +export const getMongodbflexUserOutput: typeof import("./getMongodbflexUser").getMongodbflexUserOutput = null as any; +utilities.lazyLoad(exports, ["getMongodbflexUser","getMongodbflexUserOutput"], () => require("./getMongodbflexUser")); + +export { GetNetworkArgs, GetNetworkResult, GetNetworkOutputArgs } from "./getNetwork"; +export const getNetwork: typeof import("./getNetwork").getNetwork = null as any; +export const getNetworkOutput: typeof import("./getNetwork").getNetworkOutput = null as any; +utilities.lazyLoad(exports, ["getNetwork","getNetworkOutput"], () => require("./getNetwork")); + +export { GetNetworkAreaArgs, GetNetworkAreaResult, GetNetworkAreaOutputArgs } from "./getNetworkArea"; +export const getNetworkArea: typeof import("./getNetworkArea").getNetworkArea = null as any; +export const getNetworkAreaOutput: typeof import("./getNetworkArea").getNetworkAreaOutput = null as any; +utilities.lazyLoad(exports, ["getNetworkArea","getNetworkAreaOutput"], () => require("./getNetworkArea")); + +export { GetNetworkAreaRouteArgs, GetNetworkAreaRouteResult, GetNetworkAreaRouteOutputArgs } from "./getNetworkAreaRoute"; +export const getNetworkAreaRoute: typeof import("./getNetworkAreaRoute").getNetworkAreaRoute = null as any; +export const getNetworkAreaRouteOutput: typeof import("./getNetworkAreaRoute").getNetworkAreaRouteOutput = null as any; +utilities.lazyLoad(exports, ["getNetworkAreaRoute","getNetworkAreaRouteOutput"], () => require("./getNetworkAreaRoute")); + +export { GetNetworkInterfaceArgs, GetNetworkInterfaceResult, GetNetworkInterfaceOutputArgs } from "./getNetworkInterface"; +export const getNetworkInterface: typeof import("./getNetworkInterface").getNetworkInterface = null as any; +export const getNetworkInterfaceOutput: typeof import("./getNetworkInterface").getNetworkInterfaceOutput = null as any; +utilities.lazyLoad(exports, ["getNetworkInterface","getNetworkInterfaceOutput"], () => require("./getNetworkInterface")); + +export { GetObjectstorageBucketArgs, GetObjectstorageBucketResult, GetObjectstorageBucketOutputArgs } from "./getObjectstorageBucket"; +export const getObjectstorageBucket: typeof import("./getObjectstorageBucket").getObjectstorageBucket = null as any; +export const getObjectstorageBucketOutput: typeof import("./getObjectstorageBucket").getObjectstorageBucketOutput = null as any; +utilities.lazyLoad(exports, ["getObjectstorageBucket","getObjectstorageBucketOutput"], () => require("./getObjectstorageBucket")); + +export { GetObjectstorageCredentialArgs, GetObjectstorageCredentialResult, GetObjectstorageCredentialOutputArgs } from "./getObjectstorageCredential"; +export const getObjectstorageCredential: typeof import("./getObjectstorageCredential").getObjectstorageCredential = null as any; +export const getObjectstorageCredentialOutput: typeof import("./getObjectstorageCredential").getObjectstorageCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getObjectstorageCredential","getObjectstorageCredentialOutput"], () => require("./getObjectstorageCredential")); + +export { GetObjectstorageCredentialsGroupArgs, GetObjectstorageCredentialsGroupResult, GetObjectstorageCredentialsGroupOutputArgs } from "./getObjectstorageCredentialsGroup"; +export const getObjectstorageCredentialsGroup: typeof import("./getObjectstorageCredentialsGroup").getObjectstorageCredentialsGroup = null as any; +export const getObjectstorageCredentialsGroupOutput: typeof import("./getObjectstorageCredentialsGroup").getObjectstorageCredentialsGroupOutput = null as any; +utilities.lazyLoad(exports, ["getObjectstorageCredentialsGroup","getObjectstorageCredentialsGroupOutput"], () => require("./getObjectstorageCredentialsGroup")); + +export { GetObservabilityAlertgroupArgs, GetObservabilityAlertgroupResult, GetObservabilityAlertgroupOutputArgs } from "./getObservabilityAlertgroup"; +export const getObservabilityAlertgroup: typeof import("./getObservabilityAlertgroup").getObservabilityAlertgroup = null as any; +export const getObservabilityAlertgroupOutput: typeof import("./getObservabilityAlertgroup").getObservabilityAlertgroupOutput = null as any; +utilities.lazyLoad(exports, ["getObservabilityAlertgroup","getObservabilityAlertgroupOutput"], () => require("./getObservabilityAlertgroup")); + +export { GetObservabilityInstanceArgs, GetObservabilityInstanceResult, GetObservabilityInstanceOutputArgs } from "./getObservabilityInstance"; +export const getObservabilityInstance: typeof import("./getObservabilityInstance").getObservabilityInstance = null as any; +export const getObservabilityInstanceOutput: typeof import("./getObservabilityInstance").getObservabilityInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getObservabilityInstance","getObservabilityInstanceOutput"], () => require("./getObservabilityInstance")); + +export { GetObservabilityLogalertgroupArgs, GetObservabilityLogalertgroupResult, GetObservabilityLogalertgroupOutputArgs } from "./getObservabilityLogalertgroup"; +export const getObservabilityLogalertgroup: typeof import("./getObservabilityLogalertgroup").getObservabilityLogalertgroup = null as any; +export const getObservabilityLogalertgroupOutput: typeof import("./getObservabilityLogalertgroup").getObservabilityLogalertgroupOutput = null as any; +utilities.lazyLoad(exports, ["getObservabilityLogalertgroup","getObservabilityLogalertgroupOutput"], () => require("./getObservabilityLogalertgroup")); + +export { GetObservabilityScrapeconfigArgs, GetObservabilityScrapeconfigResult, GetObservabilityScrapeconfigOutputArgs } from "./getObservabilityScrapeconfig"; +export const getObservabilityScrapeconfig: typeof import("./getObservabilityScrapeconfig").getObservabilityScrapeconfig = null as any; +export const getObservabilityScrapeconfigOutput: typeof import("./getObservabilityScrapeconfig").getObservabilityScrapeconfigOutput = null as any; +utilities.lazyLoad(exports, ["getObservabilityScrapeconfig","getObservabilityScrapeconfigOutput"], () => require("./getObservabilityScrapeconfig")); + +export { GetOpensearchCredentialArgs, GetOpensearchCredentialResult, GetOpensearchCredentialOutputArgs } from "./getOpensearchCredential"; +export const getOpensearchCredential: typeof import("./getOpensearchCredential").getOpensearchCredential = null as any; +export const getOpensearchCredentialOutput: typeof import("./getOpensearchCredential").getOpensearchCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getOpensearchCredential","getOpensearchCredentialOutput"], () => require("./getOpensearchCredential")); + +export { GetOpensearchInstanceArgs, GetOpensearchInstanceResult, GetOpensearchInstanceOutputArgs } from "./getOpensearchInstance"; +export const getOpensearchInstance: typeof import("./getOpensearchInstance").getOpensearchInstance = null as any; +export const getOpensearchInstanceOutput: typeof import("./getOpensearchInstance").getOpensearchInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getOpensearchInstance","getOpensearchInstanceOutput"], () => require("./getOpensearchInstance")); + +export { GetPostgresflexDatabaseArgs, GetPostgresflexDatabaseResult, GetPostgresflexDatabaseOutputArgs } from "./getPostgresflexDatabase"; +export const getPostgresflexDatabase: typeof import("./getPostgresflexDatabase").getPostgresflexDatabase = null as any; +export const getPostgresflexDatabaseOutput: typeof import("./getPostgresflexDatabase").getPostgresflexDatabaseOutput = null as any; +utilities.lazyLoad(exports, ["getPostgresflexDatabase","getPostgresflexDatabaseOutput"], () => require("./getPostgresflexDatabase")); + +export { GetPostgresflexInstanceArgs, GetPostgresflexInstanceResult, GetPostgresflexInstanceOutputArgs } from "./getPostgresflexInstance"; +export const getPostgresflexInstance: typeof import("./getPostgresflexInstance").getPostgresflexInstance = null as any; +export const getPostgresflexInstanceOutput: typeof import("./getPostgresflexInstance").getPostgresflexInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getPostgresflexInstance","getPostgresflexInstanceOutput"], () => require("./getPostgresflexInstance")); + +export { GetPostgresflexUserArgs, GetPostgresflexUserResult, GetPostgresflexUserOutputArgs } from "./getPostgresflexUser"; +export const getPostgresflexUser: typeof import("./getPostgresflexUser").getPostgresflexUser = null as any; +export const getPostgresflexUserOutput: typeof import("./getPostgresflexUser").getPostgresflexUserOutput = null as any; +utilities.lazyLoad(exports, ["getPostgresflexUser","getPostgresflexUserOutput"], () => require("./getPostgresflexUser")); + +export { GetPublicIpArgs, GetPublicIpResult, GetPublicIpOutputArgs } from "./getPublicIp"; +export const getPublicIp: typeof import("./getPublicIp").getPublicIp = null as any; +export const getPublicIpOutput: typeof import("./getPublicIp").getPublicIpOutput = null as any; +utilities.lazyLoad(exports, ["getPublicIp","getPublicIpOutput"], () => require("./getPublicIp")); + +export { GetPublicIpRangesResult } from "./getPublicIpRanges"; +export const getPublicIpRanges: typeof import("./getPublicIpRanges").getPublicIpRanges = null as any; +export const getPublicIpRangesOutput: typeof import("./getPublicIpRanges").getPublicIpRangesOutput = null as any; +utilities.lazyLoad(exports, ["getPublicIpRanges","getPublicIpRangesOutput"], () => require("./getPublicIpRanges")); + +export { GetRabbitmqCredentialArgs, GetRabbitmqCredentialResult, GetRabbitmqCredentialOutputArgs } from "./getRabbitmqCredential"; +export const getRabbitmqCredential: typeof import("./getRabbitmqCredential").getRabbitmqCredential = null as any; +export const getRabbitmqCredentialOutput: typeof import("./getRabbitmqCredential").getRabbitmqCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getRabbitmqCredential","getRabbitmqCredentialOutput"], () => require("./getRabbitmqCredential")); + +export { GetRabbitmqInstanceArgs, GetRabbitmqInstanceResult, GetRabbitmqInstanceOutputArgs } from "./getRabbitmqInstance"; +export const getRabbitmqInstance: typeof import("./getRabbitmqInstance").getRabbitmqInstance = null as any; +export const getRabbitmqInstanceOutput: typeof import("./getRabbitmqInstance").getRabbitmqInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getRabbitmqInstance","getRabbitmqInstanceOutput"], () => require("./getRabbitmqInstance")); + +export { GetRedisCredentialArgs, GetRedisCredentialResult, GetRedisCredentialOutputArgs } from "./getRedisCredential"; +export const getRedisCredential: typeof import("./getRedisCredential").getRedisCredential = null as any; +export const getRedisCredentialOutput: typeof import("./getRedisCredential").getRedisCredentialOutput = null as any; +utilities.lazyLoad(exports, ["getRedisCredential","getRedisCredentialOutput"], () => require("./getRedisCredential")); + +export { GetRedisInstanceArgs, GetRedisInstanceResult, GetRedisInstanceOutputArgs } from "./getRedisInstance"; +export const getRedisInstance: typeof import("./getRedisInstance").getRedisInstance = null as any; +export const getRedisInstanceOutput: typeof import("./getRedisInstance").getRedisInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getRedisInstance","getRedisInstanceOutput"], () => require("./getRedisInstance")); + +export { GetResourcemanagerProjectArgs, GetResourcemanagerProjectResult, GetResourcemanagerProjectOutputArgs } from "./getResourcemanagerProject"; +export const getResourcemanagerProject: typeof import("./getResourcemanagerProject").getResourcemanagerProject = null as any; +export const getResourcemanagerProjectOutput: typeof import("./getResourcemanagerProject").getResourcemanagerProjectOutput = null as any; +utilities.lazyLoad(exports, ["getResourcemanagerProject","getResourcemanagerProjectOutput"], () => require("./getResourcemanagerProject")); + +export { GetSecretsmanagerInstanceArgs, GetSecretsmanagerInstanceResult, GetSecretsmanagerInstanceOutputArgs } from "./getSecretsmanagerInstance"; +export const getSecretsmanagerInstance: typeof import("./getSecretsmanagerInstance").getSecretsmanagerInstance = null as any; +export const getSecretsmanagerInstanceOutput: typeof import("./getSecretsmanagerInstance").getSecretsmanagerInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getSecretsmanagerInstance","getSecretsmanagerInstanceOutput"], () => require("./getSecretsmanagerInstance")); + +export { GetSecretsmanagerUserArgs, GetSecretsmanagerUserResult, GetSecretsmanagerUserOutputArgs } from "./getSecretsmanagerUser"; +export const getSecretsmanagerUser: typeof import("./getSecretsmanagerUser").getSecretsmanagerUser = null as any; +export const getSecretsmanagerUserOutput: typeof import("./getSecretsmanagerUser").getSecretsmanagerUserOutput = null as any; +utilities.lazyLoad(exports, ["getSecretsmanagerUser","getSecretsmanagerUserOutput"], () => require("./getSecretsmanagerUser")); + +export { GetSecurityGroupArgs, GetSecurityGroupResult, GetSecurityGroupOutputArgs } from "./getSecurityGroup"; +export const getSecurityGroup: typeof import("./getSecurityGroup").getSecurityGroup = null as any; +export const getSecurityGroupOutput: typeof import("./getSecurityGroup").getSecurityGroupOutput = null as any; +utilities.lazyLoad(exports, ["getSecurityGroup","getSecurityGroupOutput"], () => require("./getSecurityGroup")); + +export { GetSecurityGroupRuleArgs, GetSecurityGroupRuleResult, GetSecurityGroupRuleOutputArgs } from "./getSecurityGroupRule"; +export const getSecurityGroupRule: typeof import("./getSecurityGroupRule").getSecurityGroupRule = null as any; +export const getSecurityGroupRuleOutput: typeof import("./getSecurityGroupRule").getSecurityGroupRuleOutput = null as any; +utilities.lazyLoad(exports, ["getSecurityGroupRule","getSecurityGroupRuleOutput"], () => require("./getSecurityGroupRule")); + +export { GetServerArgs, GetServerResult, GetServerOutputArgs } from "./getServer"; +export const getServer: typeof import("./getServer").getServer = null as any; +export const getServerOutput: typeof import("./getServer").getServerOutput = null as any; +utilities.lazyLoad(exports, ["getServer","getServerOutput"], () => require("./getServer")); + +export { GetServerBackupScheduleArgs, GetServerBackupScheduleResult, GetServerBackupScheduleOutputArgs } from "./getServerBackupSchedule"; +export const getServerBackupSchedule: typeof import("./getServerBackupSchedule").getServerBackupSchedule = null as any; +export const getServerBackupScheduleOutput: typeof import("./getServerBackupSchedule").getServerBackupScheduleOutput = null as any; +utilities.lazyLoad(exports, ["getServerBackupSchedule","getServerBackupScheduleOutput"], () => require("./getServerBackupSchedule")); + +export { GetServerBackupSchedulesArgs, GetServerBackupSchedulesResult, GetServerBackupSchedulesOutputArgs } from "./getServerBackupSchedules"; +export const getServerBackupSchedules: typeof import("./getServerBackupSchedules").getServerBackupSchedules = null as any; +export const getServerBackupSchedulesOutput: typeof import("./getServerBackupSchedules").getServerBackupSchedulesOutput = null as any; +utilities.lazyLoad(exports, ["getServerBackupSchedules","getServerBackupSchedulesOutput"], () => require("./getServerBackupSchedules")); + +export { GetServerUpdateScheduleArgs, GetServerUpdateScheduleResult, GetServerUpdateScheduleOutputArgs } from "./getServerUpdateSchedule"; +export const getServerUpdateSchedule: typeof import("./getServerUpdateSchedule").getServerUpdateSchedule = null as any; +export const getServerUpdateScheduleOutput: typeof import("./getServerUpdateSchedule").getServerUpdateScheduleOutput = null as any; +utilities.lazyLoad(exports, ["getServerUpdateSchedule","getServerUpdateScheduleOutput"], () => require("./getServerUpdateSchedule")); + +export { GetServerUpdateSchedulesArgs, GetServerUpdateSchedulesResult, GetServerUpdateSchedulesOutputArgs } from "./getServerUpdateSchedules"; +export const getServerUpdateSchedules: typeof import("./getServerUpdateSchedules").getServerUpdateSchedules = null as any; +export const getServerUpdateSchedulesOutput: typeof import("./getServerUpdateSchedules").getServerUpdateSchedulesOutput = null as any; +utilities.lazyLoad(exports, ["getServerUpdateSchedules","getServerUpdateSchedulesOutput"], () => require("./getServerUpdateSchedules")); + +export { GetServiceAccountArgs, GetServiceAccountResult, GetServiceAccountOutputArgs } from "./getServiceAccount"; +export const getServiceAccount: typeof import("./getServiceAccount").getServiceAccount = null as any; +export const getServiceAccountOutput: typeof import("./getServiceAccount").getServiceAccountOutput = null as any; +utilities.lazyLoad(exports, ["getServiceAccount","getServiceAccountOutput"], () => require("./getServiceAccount")); + +export { GetSkeClusterArgs, GetSkeClusterResult, GetSkeClusterOutputArgs } from "./getSkeCluster"; +export const getSkeCluster: typeof import("./getSkeCluster").getSkeCluster = null as any; +export const getSkeClusterOutput: typeof import("./getSkeCluster").getSkeClusterOutput = null as any; +utilities.lazyLoad(exports, ["getSkeCluster","getSkeClusterOutput"], () => require("./getSkeCluster")); + +export { GetSqlserverflexInstanceArgs, GetSqlserverflexInstanceResult, GetSqlserverflexInstanceOutputArgs } from "./getSqlserverflexInstance"; +export const getSqlserverflexInstance: typeof import("./getSqlserverflexInstance").getSqlserverflexInstance = null as any; +export const getSqlserverflexInstanceOutput: typeof import("./getSqlserverflexInstance").getSqlserverflexInstanceOutput = null as any; +utilities.lazyLoad(exports, ["getSqlserverflexInstance","getSqlserverflexInstanceOutput"], () => require("./getSqlserverflexInstance")); + +export { GetSqlserverflexUserArgs, GetSqlserverflexUserResult, GetSqlserverflexUserOutputArgs } from "./getSqlserverflexUser"; +export const getSqlserverflexUser: typeof import("./getSqlserverflexUser").getSqlserverflexUser = null as any; +export const getSqlserverflexUserOutput: typeof import("./getSqlserverflexUser").getSqlserverflexUserOutput = null as any; +utilities.lazyLoad(exports, ["getSqlserverflexUser","getSqlserverflexUserOutput"], () => require("./getSqlserverflexUser")); + +export { GetVolumeArgs, GetVolumeResult, GetVolumeOutputArgs } from "./getVolume"; +export const getVolume: typeof import("./getVolume").getVolume = null as any; +export const getVolumeOutput: typeof import("./getVolume").getVolumeOutput = null as any; +utilities.lazyLoad(exports, ["getVolume","getVolumeOutput"], () => require("./getVolume")); + +export { GitArgs, GitState } from "./git"; +export type Git = import("./git").Git; +export const Git: typeof import("./git").Git = null as any; +utilities.lazyLoad(exports, ["Git"], () => require("./git")); + +export { ImageArgs, ImageState } from "./image"; +export type Image = import("./image").Image; +export const Image: typeof import("./image").Image = null as any; +utilities.lazyLoad(exports, ["Image"], () => require("./image")); + +export { KeyPairArgs, KeyPairState } from "./keyPair"; +export type KeyPair = import("./keyPair").KeyPair; +export const KeyPair: typeof import("./keyPair").KeyPair = null as any; +utilities.lazyLoad(exports, ["KeyPair"], () => require("./keyPair")); + +export { LoadbalancerArgs, LoadbalancerState } from "./loadbalancer"; +export type Loadbalancer = import("./loadbalancer").Loadbalancer; +export const Loadbalancer: typeof import("./loadbalancer").Loadbalancer = null as any; +utilities.lazyLoad(exports, ["Loadbalancer"], () => require("./loadbalancer")); + +export { LoadbalancerObservabilityCredentialArgs, LoadbalancerObservabilityCredentialState } from "./loadbalancerObservabilityCredential"; +export type LoadbalancerObservabilityCredential = import("./loadbalancerObservabilityCredential").LoadbalancerObservabilityCredential; +export const LoadbalancerObservabilityCredential: typeof import("./loadbalancerObservabilityCredential").LoadbalancerObservabilityCredential = null as any; +utilities.lazyLoad(exports, ["LoadbalancerObservabilityCredential"], () => require("./loadbalancerObservabilityCredential")); + +export { LogmeCredentialArgs, LogmeCredentialState } from "./logmeCredential"; +export type LogmeCredential = import("./logmeCredential").LogmeCredential; +export const LogmeCredential: typeof import("./logmeCredential").LogmeCredential = null as any; +utilities.lazyLoad(exports, ["LogmeCredential"], () => require("./logmeCredential")); + +export { LogmeInstanceArgs, LogmeInstanceState } from "./logmeInstance"; +export type LogmeInstance = import("./logmeInstance").LogmeInstance; +export const LogmeInstance: typeof import("./logmeInstance").LogmeInstance = null as any; +utilities.lazyLoad(exports, ["LogmeInstance"], () => require("./logmeInstance")); + +export { MariadbCredentialArgs, MariadbCredentialState } from "./mariadbCredential"; +export type MariadbCredential = import("./mariadbCredential").MariadbCredential; +export const MariadbCredential: typeof import("./mariadbCredential").MariadbCredential = null as any; +utilities.lazyLoad(exports, ["MariadbCredential"], () => require("./mariadbCredential")); + +export { MariadbInstanceArgs, MariadbInstanceState } from "./mariadbInstance"; +export type MariadbInstance = import("./mariadbInstance").MariadbInstance; +export const MariadbInstance: typeof import("./mariadbInstance").MariadbInstance = null as any; +utilities.lazyLoad(exports, ["MariadbInstance"], () => require("./mariadbInstance")); + +export { ModelservingTokenArgs, ModelservingTokenState } from "./modelservingToken"; +export type ModelservingToken = import("./modelservingToken").ModelservingToken; +export const ModelservingToken: typeof import("./modelservingToken").ModelservingToken = null as any; +utilities.lazyLoad(exports, ["ModelservingToken"], () => require("./modelservingToken")); + +export { MongodbflexInstanceArgs, MongodbflexInstanceState } from "./mongodbflexInstance"; +export type MongodbflexInstance = import("./mongodbflexInstance").MongodbflexInstance; +export const MongodbflexInstance: typeof import("./mongodbflexInstance").MongodbflexInstance = null as any; +utilities.lazyLoad(exports, ["MongodbflexInstance"], () => require("./mongodbflexInstance")); + +export { MongodbflexUserArgs, MongodbflexUserState } from "./mongodbflexUser"; +export type MongodbflexUser = import("./mongodbflexUser").MongodbflexUser; +export const MongodbflexUser: typeof import("./mongodbflexUser").MongodbflexUser = null as any; +utilities.lazyLoad(exports, ["MongodbflexUser"], () => require("./mongodbflexUser")); + +export { NetworkArgs, NetworkState } from "./network"; +export type Network = import("./network").Network; +export const Network: typeof import("./network").Network = null as any; +utilities.lazyLoad(exports, ["Network"], () => require("./network")); + +export { NetworkAreaArgs, NetworkAreaState } from "./networkArea"; +export type NetworkArea = import("./networkArea").NetworkArea; +export const NetworkArea: typeof import("./networkArea").NetworkArea = null as any; +utilities.lazyLoad(exports, ["NetworkArea"], () => require("./networkArea")); + +export { NetworkAreaRouteArgs, NetworkAreaRouteState } from "./networkAreaRoute"; +export type NetworkAreaRoute = import("./networkAreaRoute").NetworkAreaRoute; +export const NetworkAreaRoute: typeof import("./networkAreaRoute").NetworkAreaRoute = null as any; +utilities.lazyLoad(exports, ["NetworkAreaRoute"], () => require("./networkAreaRoute")); + +export { NetworkInterfaceArgs, NetworkInterfaceState } from "./networkInterface"; +export type NetworkInterface = import("./networkInterface").NetworkInterface; +export const NetworkInterface: typeof import("./networkInterface").NetworkInterface = null as any; +utilities.lazyLoad(exports, ["NetworkInterface"], () => require("./networkInterface")); + +export { ObjectstorageBucketArgs, ObjectstorageBucketState } from "./objectstorageBucket"; +export type ObjectstorageBucket = import("./objectstorageBucket").ObjectstorageBucket; +export const ObjectstorageBucket: typeof import("./objectstorageBucket").ObjectstorageBucket = null as any; +utilities.lazyLoad(exports, ["ObjectstorageBucket"], () => require("./objectstorageBucket")); + +export { ObjectstorageCredentialArgs, ObjectstorageCredentialState } from "./objectstorageCredential"; +export type ObjectstorageCredential = import("./objectstorageCredential").ObjectstorageCredential; +export const ObjectstorageCredential: typeof import("./objectstorageCredential").ObjectstorageCredential = null as any; +utilities.lazyLoad(exports, ["ObjectstorageCredential"], () => require("./objectstorageCredential")); + +export { ObjectstorageCredentialsGroupArgs, ObjectstorageCredentialsGroupState } from "./objectstorageCredentialsGroup"; +export type ObjectstorageCredentialsGroup = import("./objectstorageCredentialsGroup").ObjectstorageCredentialsGroup; +export const ObjectstorageCredentialsGroup: typeof import("./objectstorageCredentialsGroup").ObjectstorageCredentialsGroup = null as any; +utilities.lazyLoad(exports, ["ObjectstorageCredentialsGroup"], () => require("./objectstorageCredentialsGroup")); + +export { ObservabilityAlertgroupArgs, ObservabilityAlertgroupState } from "./observabilityAlertgroup"; +export type ObservabilityAlertgroup = import("./observabilityAlertgroup").ObservabilityAlertgroup; +export const ObservabilityAlertgroup: typeof import("./observabilityAlertgroup").ObservabilityAlertgroup = null as any; +utilities.lazyLoad(exports, ["ObservabilityAlertgroup"], () => require("./observabilityAlertgroup")); + +export { ObservabilityCredentialArgs, ObservabilityCredentialState } from "./observabilityCredential"; +export type ObservabilityCredential = import("./observabilityCredential").ObservabilityCredential; +export const ObservabilityCredential: typeof import("./observabilityCredential").ObservabilityCredential = null as any; +utilities.lazyLoad(exports, ["ObservabilityCredential"], () => require("./observabilityCredential")); + +export { ObservabilityInstanceArgs, ObservabilityInstanceState } from "./observabilityInstance"; +export type ObservabilityInstance = import("./observabilityInstance").ObservabilityInstance; +export const ObservabilityInstance: typeof import("./observabilityInstance").ObservabilityInstance = null as any; +utilities.lazyLoad(exports, ["ObservabilityInstance"], () => require("./observabilityInstance")); + +export { ObservabilityLogalertgroupArgs, ObservabilityLogalertgroupState } from "./observabilityLogalertgroup"; +export type ObservabilityLogalertgroup = import("./observabilityLogalertgroup").ObservabilityLogalertgroup; +export const ObservabilityLogalertgroup: typeof import("./observabilityLogalertgroup").ObservabilityLogalertgroup = null as any; +utilities.lazyLoad(exports, ["ObservabilityLogalertgroup"], () => require("./observabilityLogalertgroup")); + +export { ObservabilityScrapeconfigArgs, ObservabilityScrapeconfigState } from "./observabilityScrapeconfig"; +export type ObservabilityScrapeconfig = import("./observabilityScrapeconfig").ObservabilityScrapeconfig; +export const ObservabilityScrapeconfig: typeof import("./observabilityScrapeconfig").ObservabilityScrapeconfig = null as any; +utilities.lazyLoad(exports, ["ObservabilityScrapeconfig"], () => require("./observabilityScrapeconfig")); + +export { OpensearchCredentialArgs, OpensearchCredentialState } from "./opensearchCredential"; +export type OpensearchCredential = import("./opensearchCredential").OpensearchCredential; +export const OpensearchCredential: typeof import("./opensearchCredential").OpensearchCredential = null as any; +utilities.lazyLoad(exports, ["OpensearchCredential"], () => require("./opensearchCredential")); + +export { OpensearchInstanceArgs, OpensearchInstanceState } from "./opensearchInstance"; +export type OpensearchInstance = import("./opensearchInstance").OpensearchInstance; +export const OpensearchInstance: typeof import("./opensearchInstance").OpensearchInstance = null as any; +utilities.lazyLoad(exports, ["OpensearchInstance"], () => require("./opensearchInstance")); + +export { PostgresflexDatabaseArgs, PostgresflexDatabaseState } from "./postgresflexDatabase"; +export type PostgresflexDatabase = import("./postgresflexDatabase").PostgresflexDatabase; +export const PostgresflexDatabase: typeof import("./postgresflexDatabase").PostgresflexDatabase = null as any; +utilities.lazyLoad(exports, ["PostgresflexDatabase"], () => require("./postgresflexDatabase")); + +export { PostgresflexInstanceArgs, PostgresflexInstanceState } from "./postgresflexInstance"; +export type PostgresflexInstance = import("./postgresflexInstance").PostgresflexInstance; +export const PostgresflexInstance: typeof import("./postgresflexInstance").PostgresflexInstance = null as any; +utilities.lazyLoad(exports, ["PostgresflexInstance"], () => require("./postgresflexInstance")); + +export { PostgresflexUserArgs, PostgresflexUserState } from "./postgresflexUser"; +export type PostgresflexUser = import("./postgresflexUser").PostgresflexUser; +export const PostgresflexUser: typeof import("./postgresflexUser").PostgresflexUser = null as any; +utilities.lazyLoad(exports, ["PostgresflexUser"], () => require("./postgresflexUser")); + +export * from "./provider"; +import { Provider } from "./provider"; + +export { PublicIpArgs, PublicIpState } from "./publicIp"; +export type PublicIp = import("./publicIp").PublicIp; +export const PublicIp: typeof import("./publicIp").PublicIp = null as any; +utilities.lazyLoad(exports, ["PublicIp"], () => require("./publicIp")); + +export { PublicIpAssociateArgs, PublicIpAssociateState } from "./publicIpAssociate"; +export type PublicIpAssociate = import("./publicIpAssociate").PublicIpAssociate; +export const PublicIpAssociate: typeof import("./publicIpAssociate").PublicIpAssociate = null as any; +utilities.lazyLoad(exports, ["PublicIpAssociate"], () => require("./publicIpAssociate")); + +export { RabbitmqCredentialArgs, RabbitmqCredentialState } from "./rabbitmqCredential"; +export type RabbitmqCredential = import("./rabbitmqCredential").RabbitmqCredential; +export const RabbitmqCredential: typeof import("./rabbitmqCredential").RabbitmqCredential = null as any; +utilities.lazyLoad(exports, ["RabbitmqCredential"], () => require("./rabbitmqCredential")); + +export { RabbitmqInstanceArgs, RabbitmqInstanceState } from "./rabbitmqInstance"; +export type RabbitmqInstance = import("./rabbitmqInstance").RabbitmqInstance; +export const RabbitmqInstance: typeof import("./rabbitmqInstance").RabbitmqInstance = null as any; +utilities.lazyLoad(exports, ["RabbitmqInstance"], () => require("./rabbitmqInstance")); + +export { RedisCredentialArgs, RedisCredentialState } from "./redisCredential"; +export type RedisCredential = import("./redisCredential").RedisCredential; +export const RedisCredential: typeof import("./redisCredential").RedisCredential = null as any; +utilities.lazyLoad(exports, ["RedisCredential"], () => require("./redisCredential")); + +export { RedisInstanceArgs, RedisInstanceState } from "./redisInstance"; +export type RedisInstance = import("./redisInstance").RedisInstance; +export const RedisInstance: typeof import("./redisInstance").RedisInstance = null as any; +utilities.lazyLoad(exports, ["RedisInstance"], () => require("./redisInstance")); + +export { ResourcemanagerProjectArgs, ResourcemanagerProjectState } from "./resourcemanagerProject"; +export type ResourcemanagerProject = import("./resourcemanagerProject").ResourcemanagerProject; +export const ResourcemanagerProject: typeof import("./resourcemanagerProject").ResourcemanagerProject = null as any; +utilities.lazyLoad(exports, ["ResourcemanagerProject"], () => require("./resourcemanagerProject")); + +export { SecretsmanagerInstanceArgs, SecretsmanagerInstanceState } from "./secretsmanagerInstance"; +export type SecretsmanagerInstance = import("./secretsmanagerInstance").SecretsmanagerInstance; +export const SecretsmanagerInstance: typeof import("./secretsmanagerInstance").SecretsmanagerInstance = null as any; +utilities.lazyLoad(exports, ["SecretsmanagerInstance"], () => require("./secretsmanagerInstance")); + +export { SecretsmanagerUserArgs, SecretsmanagerUserState } from "./secretsmanagerUser"; +export type SecretsmanagerUser = import("./secretsmanagerUser").SecretsmanagerUser; +export const SecretsmanagerUser: typeof import("./secretsmanagerUser").SecretsmanagerUser = null as any; +utilities.lazyLoad(exports, ["SecretsmanagerUser"], () => require("./secretsmanagerUser")); + +export { SecurityGroupArgs, SecurityGroupState } from "./securityGroup"; +export type SecurityGroup = import("./securityGroup").SecurityGroup; +export const SecurityGroup: typeof import("./securityGroup").SecurityGroup = null as any; +utilities.lazyLoad(exports, ["SecurityGroup"], () => require("./securityGroup")); + +export { SecurityGroupRuleArgs, SecurityGroupRuleState } from "./securityGroupRule"; +export type SecurityGroupRule = import("./securityGroupRule").SecurityGroupRule; +export const SecurityGroupRule: typeof import("./securityGroupRule").SecurityGroupRule = null as any; +utilities.lazyLoad(exports, ["SecurityGroupRule"], () => require("./securityGroupRule")); + +export { ServerArgs, ServerState } from "./server"; +export type Server = import("./server").Server; +export const Server: typeof import("./server").Server = null as any; +utilities.lazyLoad(exports, ["Server"], () => require("./server")); + +export { ServerBackupScheduleArgs, ServerBackupScheduleState } from "./serverBackupSchedule"; +export type ServerBackupSchedule = import("./serverBackupSchedule").ServerBackupSchedule; +export const ServerBackupSchedule: typeof import("./serverBackupSchedule").ServerBackupSchedule = null as any; +utilities.lazyLoad(exports, ["ServerBackupSchedule"], () => require("./serverBackupSchedule")); + +export { ServerNetworkInterfaceAttachArgs, ServerNetworkInterfaceAttachState } from "./serverNetworkInterfaceAttach"; +export type ServerNetworkInterfaceAttach = import("./serverNetworkInterfaceAttach").ServerNetworkInterfaceAttach; +export const ServerNetworkInterfaceAttach: typeof import("./serverNetworkInterfaceAttach").ServerNetworkInterfaceAttach = null as any; +utilities.lazyLoad(exports, ["ServerNetworkInterfaceAttach"], () => require("./serverNetworkInterfaceAttach")); + +export { ServerServiceAccountAttachArgs, ServerServiceAccountAttachState } from "./serverServiceAccountAttach"; +export type ServerServiceAccountAttach = import("./serverServiceAccountAttach").ServerServiceAccountAttach; +export const ServerServiceAccountAttach: typeof import("./serverServiceAccountAttach").ServerServiceAccountAttach = null as any; +utilities.lazyLoad(exports, ["ServerServiceAccountAttach"], () => require("./serverServiceAccountAttach")); + +export { ServerUpdateScheduleArgs, ServerUpdateScheduleState } from "./serverUpdateSchedule"; +export type ServerUpdateSchedule = import("./serverUpdateSchedule").ServerUpdateSchedule; +export const ServerUpdateSchedule: typeof import("./serverUpdateSchedule").ServerUpdateSchedule = null as any; +utilities.lazyLoad(exports, ["ServerUpdateSchedule"], () => require("./serverUpdateSchedule")); + +export { ServerVolumeAttachArgs, ServerVolumeAttachState } from "./serverVolumeAttach"; +export type ServerVolumeAttach = import("./serverVolumeAttach").ServerVolumeAttach; +export const ServerVolumeAttach: typeof import("./serverVolumeAttach").ServerVolumeAttach = null as any; +utilities.lazyLoad(exports, ["ServerVolumeAttach"], () => require("./serverVolumeAttach")); + +export { ServiceAccountArgs, ServiceAccountState } from "./serviceAccount"; +export type ServiceAccount = import("./serviceAccount").ServiceAccount; +export const ServiceAccount: typeof import("./serviceAccount").ServiceAccount = null as any; +utilities.lazyLoad(exports, ["ServiceAccount"], () => require("./serviceAccount")); + +export { ServiceAccountAccessTokenArgs, ServiceAccountAccessTokenState } from "./serviceAccountAccessToken"; +export type ServiceAccountAccessToken = import("./serviceAccountAccessToken").ServiceAccountAccessToken; +export const ServiceAccountAccessToken: typeof import("./serviceAccountAccessToken").ServiceAccountAccessToken = null as any; +utilities.lazyLoad(exports, ["ServiceAccountAccessToken"], () => require("./serviceAccountAccessToken")); + +export { ServiceAccountKeyArgs, ServiceAccountKeyState } from "./serviceAccountKey"; +export type ServiceAccountKey = import("./serviceAccountKey").ServiceAccountKey; +export const ServiceAccountKey: typeof import("./serviceAccountKey").ServiceAccountKey = null as any; +utilities.lazyLoad(exports, ["ServiceAccountKey"], () => require("./serviceAccountKey")); + +export { SkeClusterArgs, SkeClusterState } from "./skeCluster"; +export type SkeCluster = import("./skeCluster").SkeCluster; +export const SkeCluster: typeof import("./skeCluster").SkeCluster = null as any; +utilities.lazyLoad(exports, ["SkeCluster"], () => require("./skeCluster")); + +export { SkeKubeconfigArgs, SkeKubeconfigState } from "./skeKubeconfig"; +export type SkeKubeconfig = import("./skeKubeconfig").SkeKubeconfig; +export const SkeKubeconfig: typeof import("./skeKubeconfig").SkeKubeconfig = null as any; +utilities.lazyLoad(exports, ["SkeKubeconfig"], () => require("./skeKubeconfig")); + +export { SqlserverflexInstanceArgs, SqlserverflexInstanceState } from "./sqlserverflexInstance"; +export type SqlserverflexInstance = import("./sqlserverflexInstance").SqlserverflexInstance; +export const SqlserverflexInstance: typeof import("./sqlserverflexInstance").SqlserverflexInstance = null as any; +utilities.lazyLoad(exports, ["SqlserverflexInstance"], () => require("./sqlserverflexInstance")); + +export { SqlserverflexUserArgs, SqlserverflexUserState } from "./sqlserverflexUser"; +export type SqlserverflexUser = import("./sqlserverflexUser").SqlserverflexUser; +export const SqlserverflexUser: typeof import("./sqlserverflexUser").SqlserverflexUser = null as any; +utilities.lazyLoad(exports, ["SqlserverflexUser"], () => require("./sqlserverflexUser")); + +export { VolumeArgs, VolumeState } from "./volume"; +export type Volume = import("./volume").Volume; +export const Volume: typeof import("./volume").Volume = null as any; +utilities.lazyLoad(exports, ["Volume"], () => require("./volume")); + + +// Export sub-modules: +import * as config from "./config"; +import * as types from "./types"; + +export { + config, + types, +}; + +const _module = { + version: utilities.getVersion(), + construct: (name: string, type: string, urn: string): pulumi.Resource => { + switch (type) { + case "stackit:index/affinityGroup:AffinityGroup": + return new AffinityGroup(name, undefined, { urn }) + case "stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment": + return new AuthorizationOrganizationRoleAssignment(name, undefined, { urn }) + case "stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment": + return new AuthorizationProjectRoleAssignment(name, undefined, { urn }) + case "stackit:index/cdnCustomDomain:CdnCustomDomain": + return new CdnCustomDomain(name, undefined, { urn }) + case "stackit:index/cdnDistribution:CdnDistribution": + return new CdnDistribution(name, undefined, { urn }) + case "stackit:index/dnsRecordSet:DnsRecordSet": + return new DnsRecordSet(name, undefined, { urn }) + case "stackit:index/dnsZone:DnsZone": + return new DnsZone(name, undefined, { urn }) + case "stackit:index/git:Git": + return new Git(name, undefined, { urn }) + case "stackit:index/image:Image": + return new Image(name, undefined, { urn }) + case "stackit:index/keyPair:KeyPair": + return new KeyPair(name, undefined, { urn }) + case "stackit:index/loadbalancer:Loadbalancer": + return new Loadbalancer(name, undefined, { urn }) + case "stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential": + return new LoadbalancerObservabilityCredential(name, undefined, { urn }) + case "stackit:index/logmeCredential:LogmeCredential": + return new LogmeCredential(name, undefined, { urn }) + case "stackit:index/logmeInstance:LogmeInstance": + return new LogmeInstance(name, undefined, { urn }) + case "stackit:index/mariadbCredential:MariadbCredential": + return new MariadbCredential(name, undefined, { urn }) + case "stackit:index/mariadbInstance:MariadbInstance": + return new MariadbInstance(name, undefined, { urn }) + case "stackit:index/modelservingToken:ModelservingToken": + return new ModelservingToken(name, undefined, { urn }) + case "stackit:index/mongodbflexInstance:MongodbflexInstance": + return new MongodbflexInstance(name, undefined, { urn }) + case "stackit:index/mongodbflexUser:MongodbflexUser": + return new MongodbflexUser(name, undefined, { urn }) + case "stackit:index/network:Network": + return new Network(name, undefined, { urn }) + case "stackit:index/networkArea:NetworkArea": + return new NetworkArea(name, undefined, { urn }) + case "stackit:index/networkAreaRoute:NetworkAreaRoute": + return new NetworkAreaRoute(name, undefined, { urn }) + case "stackit:index/networkInterface:NetworkInterface": + return new NetworkInterface(name, undefined, { urn }) + case "stackit:index/objectstorageBucket:ObjectstorageBucket": + return new ObjectstorageBucket(name, undefined, { urn }) + case "stackit:index/objectstorageCredential:ObjectstorageCredential": + return new ObjectstorageCredential(name, undefined, { urn }) + case "stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup": + return new ObjectstorageCredentialsGroup(name, undefined, { urn }) + case "stackit:index/observabilityAlertgroup:ObservabilityAlertgroup": + return new ObservabilityAlertgroup(name, undefined, { urn }) + case "stackit:index/observabilityCredential:ObservabilityCredential": + return new ObservabilityCredential(name, undefined, { urn }) + case "stackit:index/observabilityInstance:ObservabilityInstance": + return new ObservabilityInstance(name, undefined, { urn }) + case "stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup": + return new ObservabilityLogalertgroup(name, undefined, { urn }) + case "stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig": + return new ObservabilityScrapeconfig(name, undefined, { urn }) + case "stackit:index/opensearchCredential:OpensearchCredential": + return new OpensearchCredential(name, undefined, { urn }) + case "stackit:index/opensearchInstance:OpensearchInstance": + return new OpensearchInstance(name, undefined, { urn }) + case "stackit:index/postgresflexDatabase:PostgresflexDatabase": + return new PostgresflexDatabase(name, undefined, { urn }) + case "stackit:index/postgresflexInstance:PostgresflexInstance": + return new PostgresflexInstance(name, undefined, { urn }) + case "stackit:index/postgresflexUser:PostgresflexUser": + return new PostgresflexUser(name, undefined, { urn }) + case "stackit:index/publicIp:PublicIp": + return new PublicIp(name, undefined, { urn }) + case "stackit:index/publicIpAssociate:PublicIpAssociate": + return new PublicIpAssociate(name, undefined, { urn }) + case "stackit:index/rabbitmqCredential:RabbitmqCredential": + return new RabbitmqCredential(name, undefined, { urn }) + case "stackit:index/rabbitmqInstance:RabbitmqInstance": + return new RabbitmqInstance(name, undefined, { urn }) + case "stackit:index/redisCredential:RedisCredential": + return new RedisCredential(name, undefined, { urn }) + case "stackit:index/redisInstance:RedisInstance": + return new RedisInstance(name, undefined, { urn }) + case "stackit:index/resourcemanagerProject:ResourcemanagerProject": + return new ResourcemanagerProject(name, undefined, { urn }) + case "stackit:index/secretsmanagerInstance:SecretsmanagerInstance": + return new SecretsmanagerInstance(name, undefined, { urn }) + case "stackit:index/secretsmanagerUser:SecretsmanagerUser": + return new SecretsmanagerUser(name, undefined, { urn }) + case "stackit:index/securityGroup:SecurityGroup": + return new SecurityGroup(name, undefined, { urn }) + case "stackit:index/securityGroupRule:SecurityGroupRule": + return new SecurityGroupRule(name, undefined, { urn }) + case "stackit:index/server:Server": + return new Server(name, undefined, { urn }) + case "stackit:index/serverBackupSchedule:ServerBackupSchedule": + return new ServerBackupSchedule(name, undefined, { urn }) + case "stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach": + return new ServerNetworkInterfaceAttach(name, undefined, { urn }) + case "stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach": + return new ServerServiceAccountAttach(name, undefined, { urn }) + case "stackit:index/serverUpdateSchedule:ServerUpdateSchedule": + return new ServerUpdateSchedule(name, undefined, { urn }) + case "stackit:index/serverVolumeAttach:ServerVolumeAttach": + return new ServerVolumeAttach(name, undefined, { urn }) + case "stackit:index/serviceAccount:ServiceAccount": + return new ServiceAccount(name, undefined, { urn }) + case "stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken": + return new ServiceAccountAccessToken(name, undefined, { urn }) + case "stackit:index/serviceAccountKey:ServiceAccountKey": + return new ServiceAccountKey(name, undefined, { urn }) + case "stackit:index/skeCluster:SkeCluster": + return new SkeCluster(name, undefined, { urn }) + case "stackit:index/skeKubeconfig:SkeKubeconfig": + return new SkeKubeconfig(name, undefined, { urn }) + case "stackit:index/sqlserverflexInstance:SqlserverflexInstance": + return new SqlserverflexInstance(name, undefined, { urn }) + case "stackit:index/sqlserverflexUser:SqlserverflexUser": + return new SqlserverflexUser(name, undefined, { urn }) + case "stackit:index/volume:Volume": + return new Volume(name, undefined, { urn }) + default: + throw new Error(`unknown resource type ${type}`); + } + }, +}; +pulumi.runtime.registerResourceModule("stackit", "index/affinityGroup", _module) +pulumi.runtime.registerResourceModule("stackit", "index/authorizationOrganizationRoleAssignment", _module) +pulumi.runtime.registerResourceModule("stackit", "index/authorizationProjectRoleAssignment", _module) +pulumi.runtime.registerResourceModule("stackit", "index/cdnCustomDomain", _module) +pulumi.runtime.registerResourceModule("stackit", "index/cdnDistribution", _module) +pulumi.runtime.registerResourceModule("stackit", "index/dnsRecordSet", _module) +pulumi.runtime.registerResourceModule("stackit", "index/dnsZone", _module) +pulumi.runtime.registerResourceModule("stackit", "index/git", _module) +pulumi.runtime.registerResourceModule("stackit", "index/image", _module) +pulumi.runtime.registerResourceModule("stackit", "index/keyPair", _module) +pulumi.runtime.registerResourceModule("stackit", "index/loadbalancer", _module) +pulumi.runtime.registerResourceModule("stackit", "index/loadbalancerObservabilityCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/logmeCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/logmeInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/mariadbCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/mariadbInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/modelservingToken", _module) +pulumi.runtime.registerResourceModule("stackit", "index/mongodbflexInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/mongodbflexUser", _module) +pulumi.runtime.registerResourceModule("stackit", "index/network", _module) +pulumi.runtime.registerResourceModule("stackit", "index/networkArea", _module) +pulumi.runtime.registerResourceModule("stackit", "index/networkAreaRoute", _module) +pulumi.runtime.registerResourceModule("stackit", "index/networkInterface", _module) +pulumi.runtime.registerResourceModule("stackit", "index/objectstorageBucket", _module) +pulumi.runtime.registerResourceModule("stackit", "index/objectstorageCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/objectstorageCredentialsGroup", _module) +pulumi.runtime.registerResourceModule("stackit", "index/observabilityAlertgroup", _module) +pulumi.runtime.registerResourceModule("stackit", "index/observabilityCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/observabilityInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/observabilityLogalertgroup", _module) +pulumi.runtime.registerResourceModule("stackit", "index/observabilityScrapeconfig", _module) +pulumi.runtime.registerResourceModule("stackit", "index/opensearchCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/opensearchInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/postgresflexDatabase", _module) +pulumi.runtime.registerResourceModule("stackit", "index/postgresflexInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/postgresflexUser", _module) +pulumi.runtime.registerResourceModule("stackit", "index/publicIp", _module) +pulumi.runtime.registerResourceModule("stackit", "index/publicIpAssociate", _module) +pulumi.runtime.registerResourceModule("stackit", "index/rabbitmqCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/rabbitmqInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/redisCredential", _module) +pulumi.runtime.registerResourceModule("stackit", "index/redisInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/resourcemanagerProject", _module) +pulumi.runtime.registerResourceModule("stackit", "index/secretsmanagerInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/secretsmanagerUser", _module) +pulumi.runtime.registerResourceModule("stackit", "index/securityGroup", _module) +pulumi.runtime.registerResourceModule("stackit", "index/securityGroupRule", _module) +pulumi.runtime.registerResourceModule("stackit", "index/server", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serverBackupSchedule", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serverNetworkInterfaceAttach", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serverServiceAccountAttach", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serverUpdateSchedule", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serverVolumeAttach", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serviceAccount", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serviceAccountAccessToken", _module) +pulumi.runtime.registerResourceModule("stackit", "index/serviceAccountKey", _module) +pulumi.runtime.registerResourceModule("stackit", "index/skeCluster", _module) +pulumi.runtime.registerResourceModule("stackit", "index/skeKubeconfig", _module) +pulumi.runtime.registerResourceModule("stackit", "index/sqlserverflexInstance", _module) +pulumi.runtime.registerResourceModule("stackit", "index/sqlserverflexUser", _module) +pulumi.runtime.registerResourceModule("stackit", "index/volume", _module) +pulumi.runtime.registerResourcePackage("stackit", { + version: utilities.getVersion(), + constructProvider: (name: string, type: string, urn: string): pulumi.ProviderResource => { + if (type !== "pulumi:providers:stackit") { + throw new Error(`unknown provider type ${type}`); + } + return new Provider(name, undefined, { urn }); + }, +}); diff --git a/sdk/nodejs/keyPair.ts b/sdk/nodejs/keyPair.ts new file mode 100644 index 0000000..54992ab --- /dev/null +++ b/sdk/nodejs/keyPair.ts @@ -0,0 +1,125 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication. + */ +export class KeyPair extends pulumi.CustomResource { + /** + * Get an existing KeyPair 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?: KeyPairState, opts?: pulumi.CustomResourceOptions): KeyPair { + return new KeyPair(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/keyPair:KeyPair'; + + /** + * Returns true if the given object is an instance of KeyPair. 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 KeyPair { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === KeyPair.__pulumiType; + } + + /** + * The fingerprint of the public SSH key. + */ + public /*out*/ readonly fingerprint!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container. + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The name of the SSH key pair. + */ + public readonly name!: pulumi.Output; + /** + * A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + */ + public readonly publicKey!: pulumi.Output; + + /** + * Create a KeyPair 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: KeyPairArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: KeyPairArgs | KeyPairState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as KeyPairState | undefined; + resourceInputs["fingerprint"] = state ? state.fingerprint : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["publicKey"] = state ? state.publicKey : undefined; + } else { + const args = argsOrState as KeyPairArgs | undefined; + if ((!args || args.publicKey === undefined) && !opts.urn) { + throw new Error("Missing required property 'publicKey'"); + } + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["publicKey"] = args ? args.publicKey : undefined; + resourceInputs["fingerprint"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(KeyPair.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering KeyPair resources. + */ +export interface KeyPairState { + /** + * The fingerprint of the public SSH key. + */ + fingerprint?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the SSH key pair. + */ + name?: pulumi.Input; + /** + * A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + */ + publicKey?: pulumi.Input; +} + +/** + * The set of arguments for constructing a KeyPair resource. + */ +export interface KeyPairArgs { + /** + * Labels are key-value string pairs which can be attached to a resource container. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the SSH key pair. + */ + name?: pulumi.Input; + /** + * A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + */ + publicKey: pulumi.Input; +} diff --git a/sdk/nodejs/loadbalancer.ts b/sdk/nodejs/loadbalancer.ts new file mode 100644 index 0000000..6795962 --- /dev/null +++ b/sdk/nodejs/loadbalancer.ts @@ -0,0 +1,206 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ## Example Usage + */ +export class Loadbalancer extends pulumi.CustomResource { + /** + * Get an existing Loadbalancer 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?: LoadbalancerState, opts?: pulumi.CustomResourceOptions): Loadbalancer { + return new Loadbalancer(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/loadbalancer:Loadbalancer'; + + /** + * Returns true if the given object is an instance of Loadbalancer. 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 Loadbalancer { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Loadbalancer.__pulumiType; + } + + /** + * External Load Balancer IP address where this Load Balancer is exposed. + */ + public readonly externalAddress!: pulumi.Output; + /** + * List of all listeners which will accept traffic. Limited to 20. + */ + public readonly listeners!: pulumi.Output; + /** + * Load balancer name. + */ + public readonly name!: pulumi.Output; + /** + * List of networks that listeners and targets reside in. + */ + public readonly networks!: pulumi.Output; + /** + * Defines any optional functionality you want to have enabled on your load balancer. + */ + public readonly options!: pulumi.Output; + /** + * Transient private Load Balancer IP address. It can change any time. + */ + public /*out*/ readonly privateAddress!: pulumi.Output; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * List of all target pools which will be used in the Load Balancer. Limited to 20. + */ + public readonly targetPools!: pulumi.Output; + + /** + * Create a Loadbalancer 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: LoadbalancerArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: LoadbalancerArgs | LoadbalancerState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as LoadbalancerState | undefined; + resourceInputs["externalAddress"] = state ? state.externalAddress : undefined; + resourceInputs["listeners"] = state ? state.listeners : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["networks"] = state ? state.networks : undefined; + resourceInputs["options"] = state ? state.options : undefined; + resourceInputs["privateAddress"] = state ? state.privateAddress : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["targetPools"] = state ? state.targetPools : undefined; + } else { + const args = argsOrState as LoadbalancerArgs | undefined; + if ((!args || args.listeners === undefined) && !opts.urn) { + throw new Error("Missing required property 'listeners'"); + } + if ((!args || args.networks === undefined) && !opts.urn) { + throw new Error("Missing required property 'networks'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.targetPools === undefined) && !opts.urn) { + throw new Error("Missing required property 'targetPools'"); + } + resourceInputs["externalAddress"] = args ? args.externalAddress : undefined; + resourceInputs["listeners"] = args ? args.listeners : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["networks"] = args ? args.networks : undefined; + resourceInputs["options"] = args ? args.options : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["targetPools"] = args ? args.targetPools : undefined; + resourceInputs["privateAddress"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Loadbalancer.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Loadbalancer resources. + */ +export interface LoadbalancerState { + /** + * External Load Balancer IP address where this Load Balancer is exposed. + */ + externalAddress?: pulumi.Input; + /** + * List of all listeners which will accept traffic. Limited to 20. + */ + listeners?: pulumi.Input[]>; + /** + * Load balancer name. + */ + name?: pulumi.Input; + /** + * List of networks that listeners and targets reside in. + */ + networks?: pulumi.Input[]>; + /** + * Defines any optional functionality you want to have enabled on your load balancer. + */ + options?: pulumi.Input; + /** + * Transient private Load Balancer IP address. It can change any time. + */ + privateAddress?: pulumi.Input; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * List of all target pools which will be used in the Load Balancer. Limited to 20. + */ + targetPools?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a Loadbalancer resource. + */ +export interface LoadbalancerArgs { + /** + * External Load Balancer IP address where this Load Balancer is exposed. + */ + externalAddress?: pulumi.Input; + /** + * List of all listeners which will accept traffic. Limited to 20. + */ + listeners: pulumi.Input[]>; + /** + * Load balancer name. + */ + name?: pulumi.Input; + /** + * List of networks that listeners and targets reside in. + */ + networks: pulumi.Input[]>; + /** + * Defines any optional functionality you want to have enabled on your load balancer. + */ + options?: pulumi.Input; + /** + * STACKIT project ID to which the Load Balancer is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * List of all target pools which will be used in the Load Balancer. Limited to 20. + */ + targetPools: pulumi.Input[]>; +} diff --git a/sdk/nodejs/loadbalancerObservabilityCredential.ts b/sdk/nodejs/loadbalancerObservabilityCredential.ts new file mode 100644 index 0000000..b99e947 --- /dev/null +++ b/sdk/nodejs/loadbalancerObservabilityCredential.ts @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into + * + * ## Example Usage + */ +export class LoadbalancerObservabilityCredential extends pulumi.CustomResource { + /** + * Get an existing LoadbalancerObservabilityCredential 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?: LoadbalancerObservabilityCredentialState, opts?: pulumi.CustomResourceOptions): LoadbalancerObservabilityCredential { + return new LoadbalancerObservabilityCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential'; + + /** + * Returns true if the given object is an instance of LoadbalancerObservabilityCredential. 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 LoadbalancerObservabilityCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === LoadbalancerObservabilityCredential.__pulumiType; + } + + /** + * The credentials reference is used by the Load Balancer to define which credentials it will use. + */ + public /*out*/ readonly credentialsRef!: pulumi.Output; + /** + * Observability credential name. + */ + public readonly displayName!: pulumi.Output; + /** + * The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + public readonly password!: pulumi.Output; + /** + * STACKIT project ID to which the load balancer observability credential is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + public readonly username!: pulumi.Output; + + /** + * Create a LoadbalancerObservabilityCredential 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: LoadbalancerObservabilityCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: LoadbalancerObservabilityCredentialArgs | LoadbalancerObservabilityCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as LoadbalancerObservabilityCredentialState | undefined; + resourceInputs["credentialsRef"] = state ? state.credentialsRef : undefined; + resourceInputs["displayName"] = state ? state.displayName : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as LoadbalancerObservabilityCredentialArgs | undefined; + if ((!args || args.displayName === undefined) && !opts.urn) { + throw new Error("Missing required property 'displayName'"); + } + if ((!args || args.password === undefined) && !opts.urn) { + throw new Error("Missing required property 'password'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.username === undefined) && !opts.urn) { + throw new Error("Missing required property 'username'"); + } + resourceInputs["displayName"] = args ? args.displayName : undefined; + resourceInputs["password"] = args ? args.password : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["username"] = args ? args.username : undefined; + resourceInputs["credentialsRef"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(LoadbalancerObservabilityCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering LoadbalancerObservabilityCredential resources. + */ +export interface LoadbalancerObservabilityCredentialState { + /** + * The credentials reference is used by the Load Balancer to define which credentials it will use. + */ + credentialsRef?: pulumi.Input; + /** + * Observability credential name. + */ + displayName?: pulumi.Input; + /** + * The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + password?: pulumi.Input; + /** + * STACKIT project ID to which the load balancer observability credential is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a LoadbalancerObservabilityCredential resource. + */ +export interface LoadbalancerObservabilityCredentialArgs { + /** + * Observability credential name. + */ + displayName: pulumi.Input; + /** + * The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + password: pulumi.Input; + /** + * STACKIT project ID to which the load balancer observability credential is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + */ + username: pulumi.Input; +} diff --git a/sdk/nodejs/logmeCredential.ts b/sdk/nodejs/logmeCredential.ts new file mode 100644 index 0000000..18a0ffc --- /dev/null +++ b/sdk/nodejs/logmeCredential.ts @@ -0,0 +1,138 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * LogMe credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class LogmeCredential extends pulumi.CustomResource { + /** + * Get an existing LogmeCredential 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?: LogmeCredentialState, opts?: pulumi.CustomResourceOptions): LogmeCredential { + return new LogmeCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/logmeCredential:LogmeCredential'; + + /** + * Returns true if the given object is an instance of LogmeCredential. 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 LogmeCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === LogmeCredential.__pulumiType; + } + + /** + * The credential's ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + /** + * ID of the LogMe instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a LogmeCredential 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: LogmeCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: LogmeCredentialArgs | LogmeCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as LogmeCredentialState | undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as LogmeCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(LogmeCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering LogmeCredential resources. + */ +export interface LogmeCredentialState { + /** + * The credential's ID. + */ + credentialId?: pulumi.Input; + host?: pulumi.Input; + /** + * ID of the LogMe instance. + */ + instanceId?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + uri?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a LogmeCredential resource. + */ +export interface LogmeCredentialArgs { + /** + * ID of the LogMe instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/logmeInstance.ts b/sdk/nodejs/logmeInstance.ts new file mode 100644 index 0000000..e2f535a --- /dev/null +++ b/sdk/nodejs/logmeInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * LogMe instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class LogmeInstance extends pulumi.CustomResource { + /** + * Get an existing LogmeInstance 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?: LogmeInstanceState, opts?: pulumi.CustomResourceOptions): LogmeInstance { + return new LogmeInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/logmeInstance:LogmeInstance'; + + /** + * Returns true if the given object is an instance of LogmeInstance. 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 LogmeInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === LogmeInstance.__pulumiType; + } + + public /*out*/ readonly cfGuid!: pulumi.Output; + public /*out*/ readonly cfOrganizationGuid!: pulumi.Output; + public /*out*/ readonly cfSpaceGuid!: pulumi.Output; + public /*out*/ readonly dashboardUrl!: pulumi.Output; + public /*out*/ readonly imageUrl!: pulumi.Output; + /** + * ID of the LogMe instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly parameters!: pulumi.Output; + /** + * The selected plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * The selected plan name. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The service version. + */ + public readonly version!: pulumi.Output; + + /** + * Create a LogmeInstance 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: LogmeInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: LogmeInstanceArgs | LogmeInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as LogmeInstanceState | undefined; + resourceInputs["cfGuid"] = state ? state.cfGuid : undefined; + resourceInputs["cfOrganizationGuid"] = state ? state.cfOrganizationGuid : undefined; + resourceInputs["cfSpaceGuid"] = state ? state.cfSpaceGuid : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["imageUrl"] = state ? state.imageUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as LogmeInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["cfGuid"] = undefined /*out*/; + resourceInputs["cfOrganizationGuid"] = undefined /*out*/; + resourceInputs["cfSpaceGuid"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["imageUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(LogmeInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering LogmeInstance resources. + */ +export interface LogmeInstanceState { + cfGuid?: pulumi.Input; + cfOrganizationGuid?: pulumi.Input; + cfSpaceGuid?: pulumi.Input; + dashboardUrl?: pulumi.Input; + imageUrl?: pulumi.Input; + /** + * ID of the LogMe instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan ID. + */ + planId?: pulumi.Input; + /** + * The selected plan name. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The service version. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a LogmeInstance resource. + */ +export interface LogmeInstanceArgs { + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan name. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The service version. + */ + version: pulumi.Input; +} diff --git a/sdk/nodejs/mariadbCredential.ts b/sdk/nodejs/mariadbCredential.ts new file mode 100644 index 0000000..c813a63 --- /dev/null +++ b/sdk/nodejs/mariadbCredential.ts @@ -0,0 +1,146 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MariaDB credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class MariadbCredential extends pulumi.CustomResource { + /** + * Get an existing MariadbCredential 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?: MariadbCredentialState, opts?: pulumi.CustomResourceOptions): MariadbCredential { + return new MariadbCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/mariadbCredential:MariadbCredential'; + + /** + * Returns true if the given object is an instance of MariadbCredential. 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 MariadbCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === MariadbCredential.__pulumiType; + } + + /** + * The credential's ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + public /*out*/ readonly hosts!: pulumi.Output; + /** + * ID of the MariaDB instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly name!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a MariadbCredential 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: MariadbCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: MariadbCredentialArgs | MariadbCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as MariadbCredentialState | undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["hosts"] = state ? state.hosts : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as MariadbCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["hosts"] = undefined /*out*/; + resourceInputs["name"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(MariadbCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering MariadbCredential resources. + */ +export interface MariadbCredentialState { + /** + * The credential's ID. + */ + credentialId?: pulumi.Input; + host?: pulumi.Input; + hosts?: pulumi.Input[]>; + /** + * ID of the MariaDB instance. + */ + instanceId?: pulumi.Input; + name?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + uri?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a MariadbCredential resource. + */ +export interface MariadbCredentialArgs { + /** + * ID of the MariaDB instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/mariadbInstance.ts b/sdk/nodejs/mariadbInstance.ts new file mode 100644 index 0000000..3b1e079 --- /dev/null +++ b/sdk/nodejs/mariadbInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MariaDB instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class MariadbInstance extends pulumi.CustomResource { + /** + * Get an existing MariadbInstance 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?: MariadbInstanceState, opts?: pulumi.CustomResourceOptions): MariadbInstance { + return new MariadbInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/mariadbInstance:MariadbInstance'; + + /** + * Returns true if the given object is an instance of MariadbInstance. 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 MariadbInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === MariadbInstance.__pulumiType; + } + + public /*out*/ readonly cfGuid!: pulumi.Output; + public /*out*/ readonly cfOrganizationGuid!: pulumi.Output; + public /*out*/ readonly cfSpaceGuid!: pulumi.Output; + public /*out*/ readonly dashboardUrl!: pulumi.Output; + public /*out*/ readonly imageUrl!: pulumi.Output; + /** + * ID of the MariaDB instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly parameters!: pulumi.Output; + /** + * The selected plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * The selected plan name. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The service version. + */ + public readonly version!: pulumi.Output; + + /** + * Create a MariadbInstance 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: MariadbInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: MariadbInstanceArgs | MariadbInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as MariadbInstanceState | undefined; + resourceInputs["cfGuid"] = state ? state.cfGuid : undefined; + resourceInputs["cfOrganizationGuid"] = state ? state.cfOrganizationGuid : undefined; + resourceInputs["cfSpaceGuid"] = state ? state.cfSpaceGuid : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["imageUrl"] = state ? state.imageUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as MariadbInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["cfGuid"] = undefined /*out*/; + resourceInputs["cfOrganizationGuid"] = undefined /*out*/; + resourceInputs["cfSpaceGuid"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["imageUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(MariadbInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering MariadbInstance resources. + */ +export interface MariadbInstanceState { + cfGuid?: pulumi.Input; + cfOrganizationGuid?: pulumi.Input; + cfSpaceGuid?: pulumi.Input; + dashboardUrl?: pulumi.Input; + imageUrl?: pulumi.Input; + /** + * ID of the MariaDB instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan ID. + */ + planId?: pulumi.Input; + /** + * The selected plan name. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The service version. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a MariadbInstance resource. + */ +export interface MariadbInstanceArgs { + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan name. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The service version. + */ + version: pulumi.Input; +} diff --git a/sdk/nodejs/modelservingToken.ts b/sdk/nodejs/modelservingToken.ts new file mode 100644 index 0000000..03e1080 --- /dev/null +++ b/sdk/nodejs/modelservingToken.ts @@ -0,0 +1,203 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * AI Model Serving Auth Token Resource schema. + * + * ## Example Usage + * + * ### Automatically rotate AI model serving token + */ +export class ModelservingToken extends pulumi.CustomResource { + /** + * Get an existing ModelservingToken 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?: ModelservingTokenState, opts?: pulumi.CustomResourceOptions): ModelservingToken { + return new ModelservingToken(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/modelservingToken:ModelservingToken'; + + /** + * Returns true if the given object is an instance of ModelservingToken. 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 ModelservingToken { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ModelservingToken.__pulumiType; + } + + /** + * The description of the AI model serving auth token. + */ + public readonly description!: pulumi.Output; + /** + * Name of the AI model serving auth token. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the AI model serving auth token is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Region to which the AI model serving auth token is associated. If not defined, the provider region is used + */ + public readonly region!: pulumi.Output; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + public readonly rotateWhenChanged!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * State of the AI model serving auth token. + */ + public /*out*/ readonly state!: pulumi.Output; + /** + * Content of the AI model serving auth token. + */ + public /*out*/ readonly token!: pulumi.Output; + /** + * The AI model serving auth token ID. + */ + public /*out*/ readonly tokenId!: pulumi.Output; + /** + * The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + */ + public readonly ttlDuration!: pulumi.Output; + /** + * The time until the AI model serving auth token is valid. + */ + public /*out*/ readonly validUntil!: pulumi.Output; + + /** + * Create a ModelservingToken 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: ModelservingTokenArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ModelservingTokenArgs | ModelservingTokenState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ModelservingTokenState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["rotateWhenChanged"] = state ? state.rotateWhenChanged : undefined; + resourceInputs["state"] = state ? state.state : undefined; + resourceInputs["token"] = state ? state.token : undefined; + resourceInputs["tokenId"] = state ? state.tokenId : undefined; + resourceInputs["ttlDuration"] = state ? state.ttlDuration : undefined; + resourceInputs["validUntil"] = state ? state.validUntil : undefined; + } else { + const args = argsOrState as ModelservingTokenArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["rotateWhenChanged"] = args ? args.rotateWhenChanged : undefined; + resourceInputs["ttlDuration"] = args ? args.ttlDuration : undefined; + resourceInputs["state"] = undefined /*out*/; + resourceInputs["token"] = undefined /*out*/; + resourceInputs["tokenId"] = undefined /*out*/; + resourceInputs["validUntil"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["token"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ModelservingToken.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ModelservingToken resources. + */ +export interface ModelservingTokenState { + /** + * The description of the AI model serving auth token. + */ + description?: pulumi.Input; + /** + * Name of the AI model serving auth token. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the AI model serving auth token is associated. + */ + projectId?: pulumi.Input; + /** + * Region to which the AI model serving auth token is associated. If not defined, the provider region is used + */ + region?: pulumi.Input; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * State of the AI model serving auth token. + */ + state?: pulumi.Input; + /** + * Content of the AI model serving auth token. + */ + token?: pulumi.Input; + /** + * The AI model serving auth token ID. + */ + tokenId?: pulumi.Input; + /** + * The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + */ + ttlDuration?: pulumi.Input; + /** + * The time until the AI model serving auth token is valid. + */ + validUntil?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ModelservingToken resource. + */ +export interface ModelservingTokenArgs { + /** + * The description of the AI model serving auth token. + */ + description?: pulumi.Input; + /** + * Name of the AI model serving auth token. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the AI model serving auth token is associated. + */ + projectId: pulumi.Input; + /** + * Region to which the AI model serving auth token is associated. If not defined, the provider region is used + */ + region?: pulumi.Input; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + */ + ttlDuration?: pulumi.Input; +} diff --git a/sdk/nodejs/mongodbflexInstance.ts b/sdk/nodejs/mongodbflexInstance.ts new file mode 100644 index 0000000..526c6b7 --- /dev/null +++ b/sdk/nodejs/mongodbflexInstance.ts @@ -0,0 +1,189 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class MongodbflexInstance extends pulumi.CustomResource { + /** + * Get an existing MongodbflexInstance 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?: MongodbflexInstanceState, opts?: pulumi.CustomResourceOptions): MongodbflexInstance { + return new MongodbflexInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/mongodbflexInstance:MongodbflexInstance'; + + /** + * Returns true if the given object is an instance of MongodbflexInstance. 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 MongodbflexInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === MongodbflexInstance.__pulumiType; + } + + /** + * The Access Control List (ACL) for the MongoDB Flex instance. + */ + public readonly acls!: pulumi.Output; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + */ + public readonly backupSchedule!: pulumi.Output; + public readonly flavor!: pulumi.Output; + /** + * ID of the MongoDB Flex instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly options!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public readonly replicas!: pulumi.Output; + public readonly storage!: pulumi.Output; + public readonly version!: pulumi.Output; + + /** + * Create a MongodbflexInstance 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: MongodbflexInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: MongodbflexInstanceArgs | MongodbflexInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as MongodbflexInstanceState | undefined; + resourceInputs["acls"] = state ? state.acls : undefined; + resourceInputs["backupSchedule"] = state ? state.backupSchedule : undefined; + resourceInputs["flavor"] = state ? state.flavor : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["options"] = state ? state.options : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["replicas"] = state ? state.replicas : undefined; + resourceInputs["storage"] = state ? state.storage : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as MongodbflexInstanceArgs | undefined; + if ((!args || args.acls === undefined) && !opts.urn) { + throw new Error("Missing required property 'acls'"); + } + if ((!args || args.backupSchedule === undefined) && !opts.urn) { + throw new Error("Missing required property 'backupSchedule'"); + } + if ((!args || args.flavor === undefined) && !opts.urn) { + throw new Error("Missing required property 'flavor'"); + } + if ((!args || args.options === undefined) && !opts.urn) { + throw new Error("Missing required property 'options'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.replicas === undefined) && !opts.urn) { + throw new Error("Missing required property 'replicas'"); + } + if ((!args || args.storage === undefined) && !opts.urn) { + throw new Error("Missing required property 'storage'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["acls"] = args ? args.acls : undefined; + resourceInputs["backupSchedule"] = args ? args.backupSchedule : undefined; + resourceInputs["flavor"] = args ? args.flavor : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["options"] = args ? args.options : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["replicas"] = args ? args.replicas : undefined; + resourceInputs["storage"] = args ? args.storage : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["instanceId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(MongodbflexInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering MongodbflexInstance resources. + */ +export interface MongodbflexInstanceState { + /** + * The Access Control List (ACL) for the MongoDB Flex instance. + */ + acls?: pulumi.Input[]>; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + */ + backupSchedule?: pulumi.Input; + flavor?: pulumi.Input; + /** + * ID of the MongoDB Flex instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + options?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + replicas?: pulumi.Input; + storage?: pulumi.Input; + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a MongodbflexInstance resource. + */ +export interface MongodbflexInstanceArgs { + /** + * The Access Control List (ACL) for the MongoDB Flex instance. + */ + acls: pulumi.Input[]>; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + */ + backupSchedule: pulumi.Input; + flavor: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + options: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + replicas: pulumi.Input; + storage: pulumi.Input; + version: pulumi.Input; +} diff --git a/sdk/nodejs/mongodbflexUser.ts b/sdk/nodejs/mongodbflexUser.ts new file mode 100644 index 0000000..2aa3afb --- /dev/null +++ b/sdk/nodejs/mongodbflexUser.ts @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class MongodbflexUser extends pulumi.CustomResource { + /** + * Get an existing MongodbflexUser 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?: MongodbflexUserState, opts?: pulumi.CustomResourceOptions): MongodbflexUser { + return new MongodbflexUser(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/mongodbflexUser:MongodbflexUser'; + + /** + * Returns true if the given object is an instance of MongodbflexUser. 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 MongodbflexUser { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === MongodbflexUser.__pulumiType; + } + + public readonly database!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + /** + * ID of the MongoDB Flex instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + */ + public readonly roles!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + /** + * User ID. + */ + public /*out*/ readonly userId!: pulumi.Output; + public readonly username!: pulumi.Output; + + /** + * Create a MongodbflexUser 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: MongodbflexUserArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: MongodbflexUserArgs | MongodbflexUserState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as MongodbflexUserState | undefined; + resourceInputs["database"] = state ? state.database : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["roles"] = state ? state.roles : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["userId"] = state ? state.userId : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as MongodbflexUserArgs | undefined; + if ((!args || args.database === undefined) && !opts.urn) { + throw new Error("Missing required property 'database'"); + } + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.roles === undefined) && !opts.urn) { + throw new Error("Missing required property 'roles'"); + } + resourceInputs["database"] = args ? args.database : undefined; + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["roles"] = args ? args.roles : undefined; + resourceInputs["username"] = args ? args.username : undefined; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["userId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(MongodbflexUser.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering MongodbflexUser resources. + */ +export interface MongodbflexUserState { + database?: pulumi.Input; + host?: pulumi.Input; + /** + * ID of the MongoDB Flex instance. + */ + instanceId?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + */ + roles?: pulumi.Input[]>; + uri?: pulumi.Input; + /** + * User ID. + */ + userId?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a MongodbflexUser resource. + */ +export interface MongodbflexUserArgs { + database: pulumi.Input; + /** + * ID of the MongoDB Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + */ + roles: pulumi.Input[]>; + username?: pulumi.Input; +} diff --git a/sdk/nodejs/network.ts b/sdk/nodejs/network.ts new file mode 100644 index 0000000..bf8fba1 --- /dev/null +++ b/sdk/nodejs/network.ts @@ -0,0 +1,345 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class Network extends pulumi.CustomResource { + /** + * Get an existing Network 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?: NetworkState, opts?: pulumi.CustomResourceOptions): Network { + return new Network(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/network:Network'; + + /** + * Returns true if the given object is an instance of Network. 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 Network { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Network.__pulumiType; + } + + /** + * The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + public readonly ipv4Gateway!: pulumi.Output; + /** + * The IPv4 nameservers of the network. + */ + public readonly ipv4Nameservers!: pulumi.Output; + /** + * The IPv4 prefix of the network (CIDR). + */ + public readonly ipv4Prefix!: pulumi.Output; + /** + * The IPv4 prefix length of the network. + */ + public readonly ipv4PrefixLength!: pulumi.Output; + /** + * The IPv4 prefixes of the network. + */ + public /*out*/ readonly ipv4Prefixes!: pulumi.Output; + /** + * The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + public readonly ipv6Gateway!: pulumi.Output; + /** + * The IPv6 nameservers of the network. + */ + public readonly ipv6Nameservers!: pulumi.Output; + /** + * The IPv6 prefix of the network (CIDR). + */ + public readonly ipv6Prefix!: pulumi.Output; + /** + * The IPv6 prefix length of the network. + */ + public readonly ipv6PrefixLength!: pulumi.Output; + /** + * The IPv6 prefixes of the network. + */ + public /*out*/ readonly ipv6Prefixes!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The name of the network. + */ + public readonly name!: pulumi.Output; + /** + * The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + * + * @deprecated Use `ipv4Nameservers` to configure the nameservers for IPv4. + */ + public readonly nameservers!: pulumi.Output; + /** + * The network ID. + */ + public /*out*/ readonly networkId!: pulumi.Output; + /** + * If set to `true`, the network doesn't have a gateway. + */ + public readonly noIpv4Gateway!: pulumi.Output; + /** + * If set to `true`, the network doesn't have a gateway. + */ + public readonly noIpv6Gateway!: pulumi.Output; + /** + * The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + * + * @deprecated Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + */ + public /*out*/ readonly prefixes!: pulumi.Output; + /** + * STACKIT project ID to which the network is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The public IP of the network. + */ + public /*out*/ readonly publicIp!: pulumi.Output; + /** + * If set to `true`, the network is routed and therefore accessible from other networks. + */ + public readonly routed!: pulumi.Output; + + /** + * Create a Network 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: NetworkArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NetworkArgs | NetworkState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NetworkState | undefined; + resourceInputs["ipv4Gateway"] = state ? state.ipv4Gateway : undefined; + resourceInputs["ipv4Nameservers"] = state ? state.ipv4Nameservers : undefined; + resourceInputs["ipv4Prefix"] = state ? state.ipv4Prefix : undefined; + resourceInputs["ipv4PrefixLength"] = state ? state.ipv4PrefixLength : undefined; + resourceInputs["ipv4Prefixes"] = state ? state.ipv4Prefixes : undefined; + resourceInputs["ipv6Gateway"] = state ? state.ipv6Gateway : undefined; + resourceInputs["ipv6Nameservers"] = state ? state.ipv6Nameservers : undefined; + resourceInputs["ipv6Prefix"] = state ? state.ipv6Prefix : undefined; + resourceInputs["ipv6PrefixLength"] = state ? state.ipv6PrefixLength : undefined; + resourceInputs["ipv6Prefixes"] = state ? state.ipv6Prefixes : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["nameservers"] = state ? state.nameservers : undefined; + resourceInputs["networkId"] = state ? state.networkId : undefined; + resourceInputs["noIpv4Gateway"] = state ? state.noIpv4Gateway : undefined; + resourceInputs["noIpv6Gateway"] = state ? state.noIpv6Gateway : undefined; + resourceInputs["prefixes"] = state ? state.prefixes : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["publicIp"] = state ? state.publicIp : undefined; + resourceInputs["routed"] = state ? state.routed : undefined; + } else { + const args = argsOrState as NetworkArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["ipv4Gateway"] = args ? args.ipv4Gateway : undefined; + resourceInputs["ipv4Nameservers"] = args ? args.ipv4Nameservers : undefined; + resourceInputs["ipv4Prefix"] = args ? args.ipv4Prefix : undefined; + resourceInputs["ipv4PrefixLength"] = args ? args.ipv4PrefixLength : undefined; + resourceInputs["ipv6Gateway"] = args ? args.ipv6Gateway : undefined; + resourceInputs["ipv6Nameservers"] = args ? args.ipv6Nameservers : undefined; + resourceInputs["ipv6Prefix"] = args ? args.ipv6Prefix : undefined; + resourceInputs["ipv6PrefixLength"] = args ? args.ipv6PrefixLength : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["nameservers"] = args ? args.nameservers : undefined; + resourceInputs["noIpv4Gateway"] = args ? args.noIpv4Gateway : undefined; + resourceInputs["noIpv6Gateway"] = args ? args.noIpv6Gateway : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["routed"] = args ? args.routed : undefined; + resourceInputs["ipv4Prefixes"] = undefined /*out*/; + resourceInputs["ipv6Prefixes"] = undefined /*out*/; + resourceInputs["networkId"] = undefined /*out*/; + resourceInputs["prefixes"] = undefined /*out*/; + resourceInputs["publicIp"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Network.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Network resources. + */ +export interface NetworkState { + /** + * The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + ipv4Gateway?: pulumi.Input; + /** + * The IPv4 nameservers of the network. + */ + ipv4Nameservers?: pulumi.Input[]>; + /** + * The IPv4 prefix of the network (CIDR). + */ + ipv4Prefix?: pulumi.Input; + /** + * The IPv4 prefix length of the network. + */ + ipv4PrefixLength?: pulumi.Input; + /** + * The IPv4 prefixes of the network. + */ + ipv4Prefixes?: pulumi.Input[]>; + /** + * The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + ipv6Gateway?: pulumi.Input; + /** + * The IPv6 nameservers of the network. + */ + ipv6Nameservers?: pulumi.Input[]>; + /** + * The IPv6 prefix of the network (CIDR). + */ + ipv6Prefix?: pulumi.Input; + /** + * The IPv6 prefix length of the network. + */ + ipv6PrefixLength?: pulumi.Input; + /** + * The IPv6 prefixes of the network. + */ + ipv6Prefixes?: pulumi.Input[]>; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the network. + */ + name?: pulumi.Input; + /** + * The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + * + * @deprecated Use `ipv4Nameservers` to configure the nameservers for IPv4. + */ + nameservers?: pulumi.Input[]>; + /** + * The network ID. + */ + networkId?: pulumi.Input; + /** + * If set to `true`, the network doesn't have a gateway. + */ + noIpv4Gateway?: pulumi.Input; + /** + * If set to `true`, the network doesn't have a gateway. + */ + noIpv6Gateway?: pulumi.Input; + /** + * The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + * + * @deprecated Use `ipv4Prefixes` to read the prefixes of the IPv4 networks. + */ + prefixes?: pulumi.Input[]>; + /** + * STACKIT project ID to which the network is associated. + */ + projectId?: pulumi.Input; + /** + * The public IP of the network. + */ + publicIp?: pulumi.Input; + /** + * If set to `true`, the network is routed and therefore accessible from other networks. + */ + routed?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Network resource. + */ +export interface NetworkArgs { + /** + * The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + ipv4Gateway?: pulumi.Input; + /** + * The IPv4 nameservers of the network. + */ + ipv4Nameservers?: pulumi.Input[]>; + /** + * The IPv4 prefix of the network (CIDR). + */ + ipv4Prefix?: pulumi.Input; + /** + * The IPv4 prefix length of the network. + */ + ipv4PrefixLength?: pulumi.Input; + /** + * The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + */ + ipv6Gateway?: pulumi.Input; + /** + * The IPv6 nameservers of the network. + */ + ipv6Nameservers?: pulumi.Input[]>; + /** + * The IPv6 prefix of the network (CIDR). + */ + ipv6Prefix?: pulumi.Input; + /** + * The IPv6 prefix length of the network. + */ + ipv6PrefixLength?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the network. + */ + name?: pulumi.Input; + /** + * The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4Nameservers` to configure the nameservers for IPv4. + * + * @deprecated Use `ipv4Nameservers` to configure the nameservers for IPv4. + */ + nameservers?: pulumi.Input[]>; + /** + * If set to `true`, the network doesn't have a gateway. + */ + noIpv4Gateway?: pulumi.Input; + /** + * If set to `true`, the network doesn't have a gateway. + */ + noIpv6Gateway?: pulumi.Input; + /** + * STACKIT project ID to which the network is associated. + */ + projectId: pulumi.Input; + /** + * If set to `true`, the network is routed and therefore accessible from other networks. + */ + routed?: pulumi.Input; +} diff --git a/sdk/nodejs/networkArea.ts b/sdk/nodejs/networkArea.ts new file mode 100644 index 0000000..2d8efbe --- /dev/null +++ b/sdk/nodejs/networkArea.ts @@ -0,0 +1,229 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network area resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class NetworkArea extends pulumi.CustomResource { + /** + * Get an existing NetworkArea 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?: NetworkAreaState, opts?: pulumi.CustomResourceOptions): NetworkArea { + return new NetworkArea(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/networkArea:NetworkArea'; + + /** + * Returns true if the given object is an instance of NetworkArea. 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 NetworkArea { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === NetworkArea.__pulumiType; + } + + /** + * List of DNS Servers/Nameservers. + */ + public readonly defaultNameservers!: pulumi.Output; + /** + * The default prefix length for networks in the network area. + */ + public readonly defaultPrefixLength!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The maximal prefix length for networks in the network area. + */ + public readonly maxPrefixLength!: pulumi.Output; + /** + * The minimal prefix length for networks in the network area. + */ + public readonly minPrefixLength!: pulumi.Output; + /** + * The name of the network area. + */ + public readonly name!: pulumi.Output; + /** + * The network area ID. + */ + public /*out*/ readonly networkAreaId!: pulumi.Output; + /** + * List of Network ranges. + */ + public readonly networkRanges!: pulumi.Output; + /** + * STACKIT organization ID to which the network area is associated. + */ + public readonly organizationId!: pulumi.Output; + /** + * The amount of projects currently referencing this area. + */ + public /*out*/ readonly projectCount!: pulumi.Output; + /** + * Classless Inter-Domain Routing (CIDR). + */ + public readonly transferNetwork!: pulumi.Output; + + /** + * Create a NetworkArea 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: NetworkAreaArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NetworkAreaArgs | NetworkAreaState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NetworkAreaState | undefined; + resourceInputs["defaultNameservers"] = state ? state.defaultNameservers : undefined; + resourceInputs["defaultPrefixLength"] = state ? state.defaultPrefixLength : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["maxPrefixLength"] = state ? state.maxPrefixLength : undefined; + resourceInputs["minPrefixLength"] = state ? state.minPrefixLength : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["networkAreaId"] = state ? state.networkAreaId : undefined; + resourceInputs["networkRanges"] = state ? state.networkRanges : undefined; + resourceInputs["organizationId"] = state ? state.organizationId : undefined; + resourceInputs["projectCount"] = state ? state.projectCount : undefined; + resourceInputs["transferNetwork"] = state ? state.transferNetwork : undefined; + } else { + const args = argsOrState as NetworkAreaArgs | undefined; + if ((!args || args.networkRanges === undefined) && !opts.urn) { + throw new Error("Missing required property 'networkRanges'"); + } + if ((!args || args.organizationId === undefined) && !opts.urn) { + throw new Error("Missing required property 'organizationId'"); + } + if ((!args || args.transferNetwork === undefined) && !opts.urn) { + throw new Error("Missing required property 'transferNetwork'"); + } + resourceInputs["defaultNameservers"] = args ? args.defaultNameservers : undefined; + resourceInputs["defaultPrefixLength"] = args ? args.defaultPrefixLength : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["maxPrefixLength"] = args ? args.maxPrefixLength : undefined; + resourceInputs["minPrefixLength"] = args ? args.minPrefixLength : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["networkRanges"] = args ? args.networkRanges : undefined; + resourceInputs["organizationId"] = args ? args.organizationId : undefined; + resourceInputs["transferNetwork"] = args ? args.transferNetwork : undefined; + resourceInputs["networkAreaId"] = undefined /*out*/; + resourceInputs["projectCount"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(NetworkArea.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering NetworkArea resources. + */ +export interface NetworkAreaState { + /** + * List of DNS Servers/Nameservers. + */ + defaultNameservers?: pulumi.Input[]>; + /** + * The default prefix length for networks in the network area. + */ + defaultPrefixLength?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The maximal prefix length for networks in the network area. + */ + maxPrefixLength?: pulumi.Input; + /** + * The minimal prefix length for networks in the network area. + */ + minPrefixLength?: pulumi.Input; + /** + * The name of the network area. + */ + name?: pulumi.Input; + /** + * The network area ID. + */ + networkAreaId?: pulumi.Input; + /** + * List of Network ranges. + */ + networkRanges?: pulumi.Input[]>; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId?: pulumi.Input; + /** + * The amount of projects currently referencing this area. + */ + projectCount?: pulumi.Input; + /** + * Classless Inter-Domain Routing (CIDR). + */ + transferNetwork?: pulumi.Input; +} + +/** + * The set of arguments for constructing a NetworkArea resource. + */ +export interface NetworkAreaArgs { + /** + * List of DNS Servers/Nameservers. + */ + defaultNameservers?: pulumi.Input[]>; + /** + * The default prefix length for networks in the network area. + */ + defaultPrefixLength?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The maximal prefix length for networks in the network area. + */ + maxPrefixLength?: pulumi.Input; + /** + * The minimal prefix length for networks in the network area. + */ + minPrefixLength?: pulumi.Input; + /** + * The name of the network area. + */ + name?: pulumi.Input; + /** + * List of Network ranges. + */ + networkRanges: pulumi.Input[]>; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: pulumi.Input; + /** + * Classless Inter-Domain Routing (CIDR). + */ + transferNetwork: pulumi.Input; +} diff --git a/sdk/nodejs/networkAreaRoute.ts b/sdk/nodejs/networkAreaRoute.ts new file mode 100644 index 0000000..36265a2 --- /dev/null +++ b/sdk/nodejs/networkAreaRoute.ts @@ -0,0 +1,164 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network area route resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class NetworkAreaRoute extends pulumi.CustomResource { + /** + * Get an existing NetworkAreaRoute 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?: NetworkAreaRouteState, opts?: pulumi.CustomResourceOptions): NetworkAreaRoute { + return new NetworkAreaRoute(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/networkAreaRoute:NetworkAreaRoute'; + + /** + * Returns true if the given object is an instance of NetworkAreaRoute. 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 NetworkAreaRoute { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === NetworkAreaRoute.__pulumiType; + } + + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The network area ID to which the network area route is associated. + */ + public readonly networkAreaId!: pulumi.Output; + /** + * The network area route ID. + */ + public /*out*/ readonly networkAreaRouteId!: pulumi.Output; + /** + * The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + */ + public readonly nextHop!: pulumi.Output; + /** + * STACKIT organization ID to which the network area is associated. + */ + public readonly organizationId!: pulumi.Output; + /** + * The network, that is reachable though the Next Hop. Should use CIDR notation. + */ + public readonly prefix!: pulumi.Output; + + /** + * Create a NetworkAreaRoute 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: NetworkAreaRouteArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NetworkAreaRouteArgs | NetworkAreaRouteState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NetworkAreaRouteState | undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["networkAreaId"] = state ? state.networkAreaId : undefined; + resourceInputs["networkAreaRouteId"] = state ? state.networkAreaRouteId : undefined; + resourceInputs["nextHop"] = state ? state.nextHop : undefined; + resourceInputs["organizationId"] = state ? state.organizationId : undefined; + resourceInputs["prefix"] = state ? state.prefix : undefined; + } else { + const args = argsOrState as NetworkAreaRouteArgs | undefined; + if ((!args || args.networkAreaId === undefined) && !opts.urn) { + throw new Error("Missing required property 'networkAreaId'"); + } + if ((!args || args.nextHop === undefined) && !opts.urn) { + throw new Error("Missing required property 'nextHop'"); + } + if ((!args || args.organizationId === undefined) && !opts.urn) { + throw new Error("Missing required property 'organizationId'"); + } + if ((!args || args.prefix === undefined) && !opts.urn) { + throw new Error("Missing required property 'prefix'"); + } + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["networkAreaId"] = args ? args.networkAreaId : undefined; + resourceInputs["nextHop"] = args ? args.nextHop : undefined; + resourceInputs["organizationId"] = args ? args.organizationId : undefined; + resourceInputs["prefix"] = args ? args.prefix : undefined; + resourceInputs["networkAreaRouteId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(NetworkAreaRoute.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering NetworkAreaRoute resources. + */ +export interface NetworkAreaRouteState { + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The network area ID to which the network area route is associated. + */ + networkAreaId?: pulumi.Input; + /** + * The network area route ID. + */ + networkAreaRouteId?: pulumi.Input; + /** + * The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + */ + nextHop?: pulumi.Input; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId?: pulumi.Input; + /** + * The network, that is reachable though the Next Hop. Should use CIDR notation. + */ + prefix?: pulumi.Input; +} + +/** + * The set of arguments for constructing a NetworkAreaRoute resource. + */ +export interface NetworkAreaRouteArgs { + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The network area ID to which the network area route is associated. + */ + networkAreaId: pulumi.Input; + /** + * The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + */ + nextHop: pulumi.Input; + /** + * STACKIT organization ID to which the network area is associated. + */ + organizationId: pulumi.Input; + /** + * The network, that is reachable though the Next Hop. Should use CIDR notation. + */ + prefix: pulumi.Input; +} diff --git a/sdk/nodejs/networkInterface.ts b/sdk/nodejs/networkInterface.ts new file mode 100644 index 0000000..8ab5eb7 --- /dev/null +++ b/sdk/nodejs/networkInterface.ts @@ -0,0 +1,230 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network interface resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class NetworkInterface extends pulumi.CustomResource { + /** + * Get an existing NetworkInterface 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?: NetworkInterfaceState, opts?: pulumi.CustomResourceOptions): NetworkInterface { + return new NetworkInterface(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/networkInterface:NetworkInterface'; + + /** + * Returns true if the given object is an instance of NetworkInterface. 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 NetworkInterface { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === NetworkInterface.__pulumiType; + } + + /** + * The list of CIDR (Classless Inter-Domain Routing) notations. + */ + public readonly allowedAddresses!: pulumi.Output; + /** + * The device UUID of the network interface. + */ + public /*out*/ readonly device!: pulumi.Output; + /** + * The IPv4 address. + */ + public readonly ipv4!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a network interface. + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The MAC address of network interface. + */ + public /*out*/ readonly mac!: pulumi.Output; + /** + * The name of the network interface. + */ + public readonly name!: pulumi.Output; + /** + * The network ID to which the network interface is associated. + */ + public readonly networkId!: pulumi.Output; + /** + * The network interface ID. + */ + public /*out*/ readonly networkInterfaceId!: pulumi.Output; + /** + * STACKIT project ID to which the network is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The Network Interface Security. If set to false, then no security groups will apply to this network interface. + */ + public readonly security!: pulumi.Output; + /** + * The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + */ + public readonly securityGroupIds!: pulumi.Output; + /** + * Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + */ + public /*out*/ readonly type!: pulumi.Output; + + /** + * Create a NetworkInterface 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: NetworkInterfaceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: NetworkInterfaceArgs | NetworkInterfaceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as NetworkInterfaceState | undefined; + resourceInputs["allowedAddresses"] = state ? state.allowedAddresses : undefined; + resourceInputs["device"] = state ? state.device : undefined; + resourceInputs["ipv4"] = state ? state.ipv4 : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["mac"] = state ? state.mac : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["networkId"] = state ? state.networkId : undefined; + resourceInputs["networkInterfaceId"] = state ? state.networkInterfaceId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["security"] = state ? state.security : undefined; + resourceInputs["securityGroupIds"] = state ? state.securityGroupIds : undefined; + resourceInputs["type"] = state ? state.type : undefined; + } else { + const args = argsOrState as NetworkInterfaceArgs | undefined; + if ((!args || args.networkId === undefined) && !opts.urn) { + throw new Error("Missing required property 'networkId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["allowedAddresses"] = args ? args.allowedAddresses : undefined; + resourceInputs["ipv4"] = args ? args.ipv4 : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["networkId"] = args ? args.networkId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["security"] = args ? args.security : undefined; + resourceInputs["securityGroupIds"] = args ? args.securityGroupIds : undefined; + resourceInputs["device"] = undefined /*out*/; + resourceInputs["mac"] = undefined /*out*/; + resourceInputs["networkInterfaceId"] = undefined /*out*/; + resourceInputs["type"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(NetworkInterface.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering NetworkInterface resources. + */ +export interface NetworkInterfaceState { + /** + * The list of CIDR (Classless Inter-Domain Routing) notations. + */ + allowedAddresses?: pulumi.Input[]>; + /** + * The device UUID of the network interface. + */ + device?: pulumi.Input; + /** + * The IPv4 address. + */ + ipv4?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a network interface. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The MAC address of network interface. + */ + mac?: pulumi.Input; + /** + * The name of the network interface. + */ + name?: pulumi.Input; + /** + * The network ID to which the network interface is associated. + */ + networkId?: pulumi.Input; + /** + * The network interface ID. + */ + networkInterfaceId?: pulumi.Input; + /** + * STACKIT project ID to which the network is associated. + */ + projectId?: pulumi.Input; + /** + * The Network Interface Security. If set to false, then no security groups will apply to this network interface. + */ + security?: pulumi.Input; + /** + * The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + */ + securityGroupIds?: pulumi.Input[]>; + /** + * Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + */ + type?: pulumi.Input; +} + +/** + * The set of arguments for constructing a NetworkInterface resource. + */ +export interface NetworkInterfaceArgs { + /** + * The list of CIDR (Classless Inter-Domain Routing) notations. + */ + allowedAddresses?: pulumi.Input[]>; + /** + * The IPv4 address. + */ + ipv4?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a network interface. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the network interface. + */ + name?: pulumi.Input; + /** + * The network ID to which the network interface is associated. + */ + networkId: pulumi.Input; + /** + * STACKIT project ID to which the network is associated. + */ + projectId: pulumi.Input; + /** + * The Network Interface Security. If set to false, then no security groups will apply to this network interface. + */ + security?: pulumi.Input; + /** + * The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + */ + securityGroupIds?: pulumi.Input[]>; +} diff --git a/sdk/nodejs/objectstorageBucket.ts b/sdk/nodejs/objectstorageBucket.ts new file mode 100644 index 0000000..1219797 --- /dev/null +++ b/sdk/nodejs/objectstorageBucket.ts @@ -0,0 +1,125 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `dependsOn` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + * + * ## Example Usage + */ +export class ObjectstorageBucket extends pulumi.CustomResource { + /** + * Get an existing ObjectstorageBucket 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?: ObjectstorageBucketState, opts?: pulumi.CustomResourceOptions): ObjectstorageBucket { + return new ObjectstorageBucket(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/objectstorageBucket:ObjectstorageBucket'; + + /** + * Returns true if the given object is an instance of ObjectstorageBucket. 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 ObjectstorageBucket { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObjectstorageBucket.__pulumiType; + } + + /** + * The bucket name. It must be DNS conform. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT Project ID to which the bucket is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + public /*out*/ readonly urlPathStyle!: pulumi.Output; + public /*out*/ readonly urlVirtualHostedStyle!: pulumi.Output; + + /** + * Create a ObjectstorageBucket 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: ObjectstorageBucketArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObjectstorageBucketArgs | ObjectstorageBucketState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObjectstorageBucketState | undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["urlPathStyle"] = state ? state.urlPathStyle : undefined; + resourceInputs["urlVirtualHostedStyle"] = state ? state.urlVirtualHostedStyle : undefined; + } else { + const args = argsOrState as ObjectstorageBucketArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["urlPathStyle"] = undefined /*out*/; + resourceInputs["urlVirtualHostedStyle"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ObjectstorageBucket.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObjectstorageBucket resources. + */ +export interface ObjectstorageBucketState { + /** + * The bucket name. It must be DNS conform. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the bucket is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + urlPathStyle?: pulumi.Input; + urlVirtualHostedStyle?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ObjectstorageBucket resource. + */ +export interface ObjectstorageBucketArgs { + /** + * The bucket name. It must be DNS conform. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the bucket is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/objectstorageCredential.ts b/sdk/nodejs/objectstorageCredential.ts new file mode 100644 index 0000000..f686296 --- /dev/null +++ b/sdk/nodejs/objectstorageCredential.ts @@ -0,0 +1,158 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObjectstorageCredential extends pulumi.CustomResource { + /** + * Get an existing ObjectstorageCredential 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?: ObjectstorageCredentialState, opts?: pulumi.CustomResourceOptions): ObjectstorageCredential { + return new ObjectstorageCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/objectstorageCredential:ObjectstorageCredential'; + + /** + * Returns true if the given object is an instance of ObjectstorageCredential. 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 ObjectstorageCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObjectstorageCredential.__pulumiType; + } + + public /*out*/ readonly accessKey!: pulumi.Output; + /** + * The credential ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + /** + * The credential group ID. + */ + public readonly credentialsGroupId!: pulumi.Output; + /** + * Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + */ + public readonly expirationTimestamp!: pulumi.Output; + public /*out*/ readonly name!: pulumi.Output; + /** + * STACKIT Project ID to which the credential group is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + public /*out*/ readonly secretAccessKey!: pulumi.Output; + + /** + * Create a ObjectstorageCredential 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: ObjectstorageCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObjectstorageCredentialArgs | ObjectstorageCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObjectstorageCredentialState | undefined; + resourceInputs["accessKey"] = state ? state.accessKey : undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["credentialsGroupId"] = state ? state.credentialsGroupId : undefined; + resourceInputs["expirationTimestamp"] = state ? state.expirationTimestamp : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["secretAccessKey"] = state ? state.secretAccessKey : undefined; + } else { + const args = argsOrState as ObjectstorageCredentialArgs | undefined; + if ((!args || args.credentialsGroupId === undefined) && !opts.urn) { + throw new Error("Missing required property 'credentialsGroupId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["credentialsGroupId"] = args ? args.credentialsGroupId : undefined; + resourceInputs["expirationTimestamp"] = args ? args.expirationTimestamp : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["accessKey"] = undefined /*out*/; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["name"] = undefined /*out*/; + resourceInputs["secretAccessKey"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["secretAccessKey"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ObjectstorageCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObjectstorageCredential resources. + */ +export interface ObjectstorageCredentialState { + accessKey?: pulumi.Input; + /** + * The credential ID. + */ + credentialId?: pulumi.Input; + /** + * The credential group ID. + */ + credentialsGroupId?: pulumi.Input; + /** + * Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + */ + expirationTimestamp?: pulumi.Input; + name?: pulumi.Input; + /** + * STACKIT Project ID to which the credential group is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + secretAccessKey?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ObjectstorageCredential resource. + */ +export interface ObjectstorageCredentialArgs { + /** + * The credential group ID. + */ + credentialsGroupId: pulumi.Input; + /** + * Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + */ + expirationTimestamp?: pulumi.Input; + /** + * STACKIT Project ID to which the credential group is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/objectstorageCredentialsGroup.ts b/sdk/nodejs/objectstorageCredentialsGroup.ts new file mode 100644 index 0000000..8d98c50 --- /dev/null +++ b/sdk/nodejs/objectstorageCredentialsGroup.ts @@ -0,0 +1,137 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `dependsOn` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + * + * ## Example Usage + */ +export class ObjectstorageCredentialsGroup extends pulumi.CustomResource { + /** + * Get an existing ObjectstorageCredentialsGroup 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?: ObjectstorageCredentialsGroupState, opts?: pulumi.CustomResourceOptions): ObjectstorageCredentialsGroup { + return new ObjectstorageCredentialsGroup(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup'; + + /** + * Returns true if the given object is an instance of ObjectstorageCredentialsGroup. 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 ObjectstorageCredentialsGroup { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObjectstorageCredentialsGroup.__pulumiType; + } + + /** + * The credentials group ID + */ + public /*out*/ readonly credentialsGroupId!: pulumi.Output; + /** + * The credentials group's display name. + */ + public readonly name!: pulumi.Output; + /** + * Project ID to which the credentials group is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * Credentials group uniform resource name (URN) + */ + public /*out*/ readonly urn!: pulumi.Output; + + /** + * Create a ObjectstorageCredentialsGroup 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: ObjectstorageCredentialsGroupArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObjectstorageCredentialsGroupArgs | ObjectstorageCredentialsGroupState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObjectstorageCredentialsGroupState | undefined; + resourceInputs["credentialsGroupId"] = state ? state.credentialsGroupId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["urn"] = state ? state.urn : undefined; + } else { + const args = argsOrState as ObjectstorageCredentialsGroupArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["credentialsGroupId"] = undefined /*out*/; + resourceInputs["urn"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ObjectstorageCredentialsGroup.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObjectstorageCredentialsGroup resources. + */ +export interface ObjectstorageCredentialsGroupState { + /** + * The credentials group ID + */ + credentialsGroupId?: pulumi.Input; + /** + * The credentials group's display name. + */ + name?: pulumi.Input; + /** + * Project ID to which the credentials group is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Credentials group uniform resource name (URN) + */ + urn?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ObjectstorageCredentialsGroup resource. + */ +export interface ObjectstorageCredentialsGroupArgs { + /** + * The credentials group's display name. + */ + name?: pulumi.Input; + /** + * Project ID to which the credentials group is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/observabilityAlertgroup.ts b/sdk/nodejs/observabilityAlertgroup.ts new file mode 100644 index 0000000..0adf7ca --- /dev/null +++ b/sdk/nodejs/observabilityAlertgroup.ts @@ -0,0 +1,153 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObservabilityAlertgroup extends pulumi.CustomResource { + /** + * Get an existing ObservabilityAlertgroup 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?: ObservabilityAlertgroupState, opts?: pulumi.CustomResourceOptions): ObservabilityAlertgroup { + return new ObservabilityAlertgroup(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/observabilityAlertgroup:ObservabilityAlertgroup'; + + /** + * Returns true if the given object is an instance of ObservabilityAlertgroup. 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 ObservabilityAlertgroup { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObservabilityAlertgroup.__pulumiType; + } + + /** + * Observability instance ID to which the alert group is associated. + */ + public readonly instanceId!: pulumi.Output; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + public readonly interval!: pulumi.Output; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the alert group is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Rules for the alert group + */ + public readonly rules!: pulumi.Output; + + /** + * Create a ObservabilityAlertgroup 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: ObservabilityAlertgroupArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObservabilityAlertgroupArgs | ObservabilityAlertgroupState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObservabilityAlertgroupState | undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["interval"] = state ? state.interval : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["rules"] = state ? state.rules : undefined; + } else { + const args = argsOrState as ObservabilityAlertgroupArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.rules === undefined) && !opts.urn) { + throw new Error("Missing required property 'rules'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["interval"] = args ? args.interval : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["rules"] = args ? args.rules : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ObservabilityAlertgroup.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObservabilityAlertgroup resources. + */ +export interface ObservabilityAlertgroupState { + /** + * Observability instance ID to which the alert group is associated. + */ + instanceId?: pulumi.Input; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + interval?: pulumi.Input; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the alert group is associated. + */ + projectId?: pulumi.Input; + /** + * Rules for the alert group + */ + rules?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a ObservabilityAlertgroup resource. + */ +export interface ObservabilityAlertgroupArgs { + /** + * Observability instance ID to which the alert group is associated. + */ + instanceId: pulumi.Input; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + interval?: pulumi.Input; + /** + * The name of the alert group. Is the identifier and must be unique in the group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the alert group is associated. + */ + projectId: pulumi.Input; + /** + * Rules for the alert group + */ + rules: pulumi.Input[]>; +} diff --git a/sdk/nodejs/observabilityCredential.ts b/sdk/nodejs/observabilityCredential.ts new file mode 100644 index 0000000..a45172a --- /dev/null +++ b/sdk/nodejs/observabilityCredential.ts @@ -0,0 +1,128 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObservabilityCredential extends pulumi.CustomResource { + /** + * Get an existing ObservabilityCredential 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?: ObservabilityCredentialState, opts?: pulumi.CustomResourceOptions): ObservabilityCredential { + return new ObservabilityCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/observabilityCredential:ObservabilityCredential'; + + /** + * Returns true if the given object is an instance of ObservabilityCredential. 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 ObservabilityCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObservabilityCredential.__pulumiType; + } + + /** + * The Observability Instance ID the credential belongs to. + */ + public readonly instanceId!: pulumi.Output; + /** + * Credential password + */ + public /*out*/ readonly password!: pulumi.Output; + /** + * STACKIT project ID to which the credential is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Credential username + */ + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a ObservabilityCredential 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: ObservabilityCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObservabilityCredentialArgs | ObservabilityCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObservabilityCredentialState | undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as ObservabilityCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ObservabilityCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObservabilityCredential resources. + */ +export interface ObservabilityCredentialState { + /** + * The Observability Instance ID the credential belongs to. + */ + instanceId?: pulumi.Input; + /** + * Credential password + */ + password?: pulumi.Input; + /** + * STACKIT project ID to which the credential is associated. + */ + projectId?: pulumi.Input; + /** + * Credential username + */ + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ObservabilityCredential resource. + */ +export interface ObservabilityCredentialArgs { + /** + * The Observability Instance ID the credential belongs to. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the credential is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/observabilityInstance.ts b/sdk/nodejs/observabilityInstance.ts new file mode 100644 index 0000000..1e60ef5 --- /dev/null +++ b/sdk/nodejs/observabilityInstance.ts @@ -0,0 +1,364 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObservabilityInstance extends pulumi.CustomResource { + /** + * Get an existing ObservabilityInstance 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?: ObservabilityInstanceState, opts?: pulumi.CustomResourceOptions): ObservabilityInstance { + return new ObservabilityInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/observabilityInstance:ObservabilityInstance'; + + /** + * Returns true if the given object is an instance of ObservabilityInstance. 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 ObservabilityInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObservabilityInstance.__pulumiType; + } + + /** + * The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + */ + public readonly acls!: pulumi.Output; + /** + * Alert configuration for the instance. + */ + public readonly alertConfig!: pulumi.Output; + /** + * Specifies Alerting URL. + */ + public /*out*/ readonly alertingUrl!: pulumi.Output; + /** + * Specifies Observability instance dashboard URL. + */ + public /*out*/ readonly dashboardUrl!: pulumi.Output; + /** + * Specifies an initial Grafana admin password. + */ + public /*out*/ readonly grafanaInitialAdminPassword!: pulumi.Output; + /** + * Specifies an initial Grafana admin username. + */ + public /*out*/ readonly grafanaInitialAdminUser!: pulumi.Output; + /** + * If true, anyone can access Grafana dashboards without logging in. + */ + public /*out*/ readonly grafanaPublicReadAccess!: pulumi.Output; + /** + * Specifies Grafana URL. + */ + public /*out*/ readonly grafanaUrl!: pulumi.Output; + /** + * The Observability instance ID. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Specifies if the instance can be updated. + */ + public /*out*/ readonly isUpdatable!: pulumi.Output; + public /*out*/ readonly jaegerTracesUrl!: pulumi.Output; + public /*out*/ readonly jaegerUiUrl!: pulumi.Output; + /** + * Specifies URL for pushing logs. + */ + public /*out*/ readonly logsPushUrl!: pulumi.Output; + /** + * Specifies Logs URL. + */ + public /*out*/ readonly logsUrl!: pulumi.Output; + /** + * Specifies URL for pushing metrics. + */ + public /*out*/ readonly metricsPushUrl!: pulumi.Output; + /** + * Specifies for how many days the raw metrics are kept. + */ + public readonly metricsRetentionDays!: pulumi.Output; + /** + * Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + */ + public readonly metricsRetentionDays1hDownsampling!: pulumi.Output; + /** + * Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + */ + public readonly metricsRetentionDays5mDownsampling!: pulumi.Output; + /** + * Specifies metrics URL. + */ + public /*out*/ readonly metricsUrl!: pulumi.Output; + /** + * The name of the Observability instance. + */ + public readonly name!: pulumi.Output; + public /*out*/ readonly otlpTracesUrl!: pulumi.Output; + /** + * Additional parameters. + */ + public readonly parameters!: pulumi.Output<{[key: string]: string}>; + /** + * The Observability plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Specifies Targets URL. + */ + public /*out*/ readonly targetsUrl!: pulumi.Output; + public /*out*/ readonly zipkinSpansUrl!: pulumi.Output; + + /** + * Create a ObservabilityInstance 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: ObservabilityInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObservabilityInstanceArgs | ObservabilityInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObservabilityInstanceState | undefined; + resourceInputs["acls"] = state ? state.acls : undefined; + resourceInputs["alertConfig"] = state ? state.alertConfig : undefined; + resourceInputs["alertingUrl"] = state ? state.alertingUrl : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["grafanaInitialAdminPassword"] = state ? state.grafanaInitialAdminPassword : undefined; + resourceInputs["grafanaInitialAdminUser"] = state ? state.grafanaInitialAdminUser : undefined; + resourceInputs["grafanaPublicReadAccess"] = state ? state.grafanaPublicReadAccess : undefined; + resourceInputs["grafanaUrl"] = state ? state.grafanaUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["isUpdatable"] = state ? state.isUpdatable : undefined; + resourceInputs["jaegerTracesUrl"] = state ? state.jaegerTracesUrl : undefined; + resourceInputs["jaegerUiUrl"] = state ? state.jaegerUiUrl : undefined; + resourceInputs["logsPushUrl"] = state ? state.logsPushUrl : undefined; + resourceInputs["logsUrl"] = state ? state.logsUrl : undefined; + resourceInputs["metricsPushUrl"] = state ? state.metricsPushUrl : undefined; + resourceInputs["metricsRetentionDays"] = state ? state.metricsRetentionDays : undefined; + resourceInputs["metricsRetentionDays1hDownsampling"] = state ? state.metricsRetentionDays1hDownsampling : undefined; + resourceInputs["metricsRetentionDays5mDownsampling"] = state ? state.metricsRetentionDays5mDownsampling : undefined; + resourceInputs["metricsUrl"] = state ? state.metricsUrl : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["otlpTracesUrl"] = state ? state.otlpTracesUrl : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["targetsUrl"] = state ? state.targetsUrl : undefined; + resourceInputs["zipkinSpansUrl"] = state ? state.zipkinSpansUrl : undefined; + } else { + const args = argsOrState as ObservabilityInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["acls"] = args ? args.acls : undefined; + resourceInputs["alertConfig"] = args ? args.alertConfig : undefined; + resourceInputs["metricsRetentionDays"] = args ? args.metricsRetentionDays : undefined; + resourceInputs["metricsRetentionDays1hDownsampling"] = args ? args.metricsRetentionDays1hDownsampling : undefined; + resourceInputs["metricsRetentionDays5mDownsampling"] = args ? args.metricsRetentionDays5mDownsampling : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["alertingUrl"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["grafanaInitialAdminPassword"] = undefined /*out*/; + resourceInputs["grafanaInitialAdminUser"] = undefined /*out*/; + resourceInputs["grafanaPublicReadAccess"] = undefined /*out*/; + resourceInputs["grafanaUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["isUpdatable"] = undefined /*out*/; + resourceInputs["jaegerTracesUrl"] = undefined /*out*/; + resourceInputs["jaegerUiUrl"] = undefined /*out*/; + resourceInputs["logsPushUrl"] = undefined /*out*/; + resourceInputs["logsUrl"] = undefined /*out*/; + resourceInputs["metricsPushUrl"] = undefined /*out*/; + resourceInputs["metricsUrl"] = undefined /*out*/; + resourceInputs["otlpTracesUrl"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + resourceInputs["targetsUrl"] = undefined /*out*/; + resourceInputs["zipkinSpansUrl"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["grafanaInitialAdminPassword"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ObservabilityInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObservabilityInstance resources. + */ +export interface ObservabilityInstanceState { + /** + * The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + */ + acls?: pulumi.Input[]>; + /** + * Alert configuration for the instance. + */ + alertConfig?: pulumi.Input; + /** + * Specifies Alerting URL. + */ + alertingUrl?: pulumi.Input; + /** + * Specifies Observability instance dashboard URL. + */ + dashboardUrl?: pulumi.Input; + /** + * Specifies an initial Grafana admin password. + */ + grafanaInitialAdminPassword?: pulumi.Input; + /** + * Specifies an initial Grafana admin username. + */ + grafanaInitialAdminUser?: pulumi.Input; + /** + * If true, anyone can access Grafana dashboards without logging in. + */ + grafanaPublicReadAccess?: pulumi.Input; + /** + * Specifies Grafana URL. + */ + grafanaUrl?: pulumi.Input; + /** + * The Observability instance ID. + */ + instanceId?: pulumi.Input; + /** + * Specifies if the instance can be updated. + */ + isUpdatable?: pulumi.Input; + jaegerTracesUrl?: pulumi.Input; + jaegerUiUrl?: pulumi.Input; + /** + * Specifies URL for pushing logs. + */ + logsPushUrl?: pulumi.Input; + /** + * Specifies Logs URL. + */ + logsUrl?: pulumi.Input; + /** + * Specifies URL for pushing metrics. + */ + metricsPushUrl?: pulumi.Input; + /** + * Specifies for how many days the raw metrics are kept. + */ + metricsRetentionDays?: pulumi.Input; + /** + * Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + */ + metricsRetentionDays1hDownsampling?: pulumi.Input; + /** + * Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + */ + metricsRetentionDays5mDownsampling?: pulumi.Input; + /** + * Specifies metrics URL. + */ + metricsUrl?: pulumi.Input; + /** + * The name of the Observability instance. + */ + name?: pulumi.Input; + otlpTracesUrl?: pulumi.Input; + /** + * Additional parameters. + */ + parameters?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The Observability plan ID. + */ + planId?: pulumi.Input; + /** + * Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * Specifies Targets URL. + */ + targetsUrl?: pulumi.Input; + zipkinSpansUrl?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ObservabilityInstance resource. + */ +export interface ObservabilityInstanceArgs { + /** + * The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + */ + acls?: pulumi.Input[]>; + /** + * Alert configuration for the instance. + */ + alertConfig?: pulumi.Input; + /** + * Specifies for how many days the raw metrics are kept. + */ + metricsRetentionDays?: pulumi.Input; + /** + * Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + */ + metricsRetentionDays1hDownsampling?: pulumi.Input; + /** + * Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + */ + metricsRetentionDays5mDownsampling?: pulumi.Input; + /** + * The name of the Observability instance. + */ + name?: pulumi.Input; + /** + * Additional parameters. + */ + parameters?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/observabilityLogalertgroup.ts b/sdk/nodejs/observabilityLogalertgroup.ts new file mode 100644 index 0000000..661cf16 --- /dev/null +++ b/sdk/nodejs/observabilityLogalertgroup.ts @@ -0,0 +1,153 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObservabilityLogalertgroup extends pulumi.CustomResource { + /** + * Get an existing ObservabilityLogalertgroup 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?: ObservabilityLogalertgroupState, opts?: pulumi.CustomResourceOptions): ObservabilityLogalertgroup { + return new ObservabilityLogalertgroup(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup'; + + /** + * Returns true if the given object is an instance of ObservabilityLogalertgroup. 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 ObservabilityLogalertgroup { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObservabilityLogalertgroup.__pulumiType; + } + + /** + * Observability instance ID to which the log alert group is associated. + */ + public readonly instanceId!: pulumi.Output; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + public readonly interval!: pulumi.Output; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the log alert group is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Rules for the log alert group + */ + public readonly rules!: pulumi.Output; + + /** + * Create a ObservabilityLogalertgroup 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: ObservabilityLogalertgroupArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObservabilityLogalertgroupArgs | ObservabilityLogalertgroupState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObservabilityLogalertgroupState | undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["interval"] = state ? state.interval : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["rules"] = state ? state.rules : undefined; + } else { + const args = argsOrState as ObservabilityLogalertgroupArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.rules === undefined) && !opts.urn) { + throw new Error("Missing required property 'rules'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["interval"] = args ? args.interval : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["rules"] = args ? args.rules : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ObservabilityLogalertgroup.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObservabilityLogalertgroup resources. + */ +export interface ObservabilityLogalertgroupState { + /** + * Observability instance ID to which the log alert group is associated. + */ + instanceId?: pulumi.Input; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + interval?: pulumi.Input; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the log alert group is associated. + */ + projectId?: pulumi.Input; + /** + * Rules for the log alert group + */ + rules?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a ObservabilityLogalertgroup resource. + */ +export interface ObservabilityLogalertgroupArgs { + /** + * Observability instance ID to which the log alert group is associated. + */ + instanceId: pulumi.Input; + /** + * Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + */ + interval?: pulumi.Input; + /** + * The name of the log alert group. Is the identifier and must be unique in the group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the log alert group is associated. + */ + projectId: pulumi.Input; + /** + * Rules for the log alert group + */ + rules: pulumi.Input[]>; +} diff --git a/sdk/nodejs/observabilityScrapeconfig.ts b/sdk/nodejs/observabilityScrapeconfig.ts new file mode 100644 index 0000000..248e2d3 --- /dev/null +++ b/sdk/nodejs/observabilityScrapeconfig.ts @@ -0,0 +1,240 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Observability scrape config resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ObservabilityScrapeconfig extends pulumi.CustomResource { + /** + * Get an existing ObservabilityScrapeconfig 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?: ObservabilityScrapeconfigState, opts?: pulumi.CustomResourceOptions): ObservabilityScrapeconfig { + return new ObservabilityScrapeconfig(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig'; + + /** + * Returns true if the given object is an instance of ObservabilityScrapeconfig. 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 ObservabilityScrapeconfig { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ObservabilityScrapeconfig.__pulumiType; + } + + /** + * A basic authentication block. + */ + public readonly basicAuth!: pulumi.Output; + /** + * Observability instance ID to which the scraping job is associated. + */ + public readonly instanceId!: pulumi.Output; + /** + * Specifies the job scraping url path. E.g. `/metrics`. + */ + public readonly metricsPath!: pulumi.Output; + /** + * Specifies the name of the scraping job. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the scraping job is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * A SAML2 configuration block. + */ + public readonly saml2!: pulumi.Output; + /** + * Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + */ + public readonly sampleLimit!: pulumi.Output; + /** + * Specifies the http scheme. Defaults to `https`. + */ + public readonly scheme!: pulumi.Output; + /** + * Specifies the scrape interval as duration string. Defaults to `5m`. + */ + public readonly scrapeInterval!: pulumi.Output; + /** + * Specifies the scrape timeout as duration string. Defaults to `2m`. + */ + public readonly scrapeTimeout!: pulumi.Output; + /** + * The targets list (specified by the static config). + */ + public readonly targets!: pulumi.Output; + + /** + * Create a ObservabilityScrapeconfig 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: ObservabilityScrapeconfigArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ObservabilityScrapeconfigArgs | ObservabilityScrapeconfigState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ObservabilityScrapeconfigState | undefined; + resourceInputs["basicAuth"] = state ? state.basicAuth : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["metricsPath"] = state ? state.metricsPath : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["saml2"] = state ? state.saml2 : undefined; + resourceInputs["sampleLimit"] = state ? state.sampleLimit : undefined; + resourceInputs["scheme"] = state ? state.scheme : undefined; + resourceInputs["scrapeInterval"] = state ? state.scrapeInterval : undefined; + resourceInputs["scrapeTimeout"] = state ? state.scrapeTimeout : undefined; + resourceInputs["targets"] = state ? state.targets : undefined; + } else { + const args = argsOrState as ObservabilityScrapeconfigArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.metricsPath === undefined) && !opts.urn) { + throw new Error("Missing required property 'metricsPath'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.targets === undefined) && !opts.urn) { + throw new Error("Missing required property 'targets'"); + } + resourceInputs["basicAuth"] = args ? args.basicAuth : undefined; + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["metricsPath"] = args ? args.metricsPath : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["saml2"] = args ? args.saml2 : undefined; + resourceInputs["sampleLimit"] = args ? args.sampleLimit : undefined; + resourceInputs["scheme"] = args ? args.scheme : undefined; + resourceInputs["scrapeInterval"] = args ? args.scrapeInterval : undefined; + resourceInputs["scrapeTimeout"] = args ? args.scrapeTimeout : undefined; + resourceInputs["targets"] = args ? args.targets : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ObservabilityScrapeconfig.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ObservabilityScrapeconfig resources. + */ +export interface ObservabilityScrapeconfigState { + /** + * A basic authentication block. + */ + basicAuth?: pulumi.Input; + /** + * Observability instance ID to which the scraping job is associated. + */ + instanceId?: pulumi.Input; + /** + * Specifies the job scraping url path. E.g. `/metrics`. + */ + metricsPath?: pulumi.Input; + /** + * Specifies the name of the scraping job. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the scraping job is associated. + */ + projectId?: pulumi.Input; + /** + * A SAML2 configuration block. + */ + saml2?: pulumi.Input; + /** + * Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + */ + sampleLimit?: pulumi.Input; + /** + * Specifies the http scheme. Defaults to `https`. + */ + scheme?: pulumi.Input; + /** + * Specifies the scrape interval as duration string. Defaults to `5m`. + */ + scrapeInterval?: pulumi.Input; + /** + * Specifies the scrape timeout as duration string. Defaults to `2m`. + */ + scrapeTimeout?: pulumi.Input; + /** + * The targets list (specified by the static config). + */ + targets?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a ObservabilityScrapeconfig resource. + */ +export interface ObservabilityScrapeconfigArgs { + /** + * A basic authentication block. + */ + basicAuth?: pulumi.Input; + /** + * Observability instance ID to which the scraping job is associated. + */ + instanceId: pulumi.Input; + /** + * Specifies the job scraping url path. E.g. `/metrics`. + */ + metricsPath: pulumi.Input; + /** + * Specifies the name of the scraping job. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the scraping job is associated. + */ + projectId: pulumi.Input; + /** + * A SAML2 configuration block. + */ + saml2?: pulumi.Input; + /** + * Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + */ + sampleLimit?: pulumi.Input; + /** + * Specifies the http scheme. Defaults to `https`. + */ + scheme?: pulumi.Input; + /** + * Specifies the scrape interval as duration string. Defaults to `5m`. + */ + scrapeInterval?: pulumi.Input; + /** + * Specifies the scrape timeout as duration string. Defaults to `2m`. + */ + scrapeTimeout?: pulumi.Input; + /** + * The targets list (specified by the static config). + */ + targets: pulumi.Input[]>; +} diff --git a/sdk/nodejs/opensearchCredential.ts b/sdk/nodejs/opensearchCredential.ts new file mode 100644 index 0000000..11e3acd --- /dev/null +++ b/sdk/nodejs/opensearchCredential.ts @@ -0,0 +1,146 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * OpenSearch credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class OpensearchCredential extends pulumi.CustomResource { + /** + * Get an existing OpensearchCredential 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?: OpensearchCredentialState, opts?: pulumi.CustomResourceOptions): OpensearchCredential { + return new OpensearchCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/opensearchCredential:OpensearchCredential'; + + /** + * Returns true if the given object is an instance of OpensearchCredential. 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 OpensearchCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === OpensearchCredential.__pulumiType; + } + + /** + * The credential's ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + public /*out*/ readonly hosts!: pulumi.Output; + /** + * ID of the OpenSearch instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public /*out*/ readonly scheme!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a OpensearchCredential 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: OpensearchCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: OpensearchCredentialArgs | OpensearchCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as OpensearchCredentialState | undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["hosts"] = state ? state.hosts : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["scheme"] = state ? state.scheme : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as OpensearchCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["hosts"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["scheme"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(OpensearchCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering OpensearchCredential resources. + */ +export interface OpensearchCredentialState { + /** + * The credential's ID. + */ + credentialId?: pulumi.Input; + host?: pulumi.Input; + hosts?: pulumi.Input[]>; + /** + * ID of the OpenSearch instance. + */ + instanceId?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + scheme?: pulumi.Input; + uri?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a OpensearchCredential resource. + */ +export interface OpensearchCredentialArgs { + /** + * ID of the OpenSearch instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/opensearchInstance.ts b/sdk/nodejs/opensearchInstance.ts new file mode 100644 index 0000000..f036b36 --- /dev/null +++ b/sdk/nodejs/opensearchInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * OpenSearch instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class OpensearchInstance extends pulumi.CustomResource { + /** + * Get an existing OpensearchInstance 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?: OpensearchInstanceState, opts?: pulumi.CustomResourceOptions): OpensearchInstance { + return new OpensearchInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/opensearchInstance:OpensearchInstance'; + + /** + * Returns true if the given object is an instance of OpensearchInstance. 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 OpensearchInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === OpensearchInstance.__pulumiType; + } + + public /*out*/ readonly cfGuid!: pulumi.Output; + public /*out*/ readonly cfOrganizationGuid!: pulumi.Output; + public /*out*/ readonly cfSpaceGuid!: pulumi.Output; + public /*out*/ readonly dashboardUrl!: pulumi.Output; + public /*out*/ readonly imageUrl!: pulumi.Output; + /** + * ID of the OpenSearch instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly parameters!: pulumi.Output; + /** + * The selected plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * The selected plan name. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The service version. + */ + public readonly version!: pulumi.Output; + + /** + * Create a OpensearchInstance 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: OpensearchInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: OpensearchInstanceArgs | OpensearchInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as OpensearchInstanceState | undefined; + resourceInputs["cfGuid"] = state ? state.cfGuid : undefined; + resourceInputs["cfOrganizationGuid"] = state ? state.cfOrganizationGuid : undefined; + resourceInputs["cfSpaceGuid"] = state ? state.cfSpaceGuid : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["imageUrl"] = state ? state.imageUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as OpensearchInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["cfGuid"] = undefined /*out*/; + resourceInputs["cfOrganizationGuid"] = undefined /*out*/; + resourceInputs["cfSpaceGuid"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["imageUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(OpensearchInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering OpensearchInstance resources. + */ +export interface OpensearchInstanceState { + cfGuid?: pulumi.Input; + cfOrganizationGuid?: pulumi.Input; + cfSpaceGuid?: pulumi.Input; + dashboardUrl?: pulumi.Input; + imageUrl?: pulumi.Input; + /** + * ID of the OpenSearch instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan ID. + */ + planId?: pulumi.Input; + /** + * The selected plan name. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The service version. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a OpensearchInstance resource. + */ +export interface OpensearchInstanceArgs { + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan name. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The service version. + */ + version: pulumi.Input; +} diff --git a/sdk/nodejs/package.json b/sdk/nodejs/package.json new file mode 100644 index 0000000..68992d1 --- /dev/null +++ b/sdk/nodejs/package.json @@ -0,0 +1,29 @@ +{ + "name": "@stackitcloud/pulumi-stackit", + "version": "${VERSION}", + "description": "A Pulumi package for creating and managing stackit resources.", + "keywords": [ + "pulumi", + "stackit", + "category/utility" + ], + "homepage": "https://www.pulumi.com", + "repository": "https://github.com/stackitcloud/pulumi-stackit", + "license": "Apache-2.0", + "scripts": { + "build": "tsc" + }, + "dependencies": { + "@pulumi/pulumi": "^3.0.0" + }, + "devDependencies": { + "@types/mime": "^2.0.0", + "@types/node": "^10.0.0", + "typescript": "^4.3.5" + }, + "pulumi": { + "resource": true, + "name": "stackit", + "server": "github://api.github.com/stackitcloud/pulumi-stackit" + } +} diff --git a/sdk/nodejs/postgresflexDatabase.ts b/sdk/nodejs/postgresflexDatabase.ts new file mode 100644 index 0000000..353d581 --- /dev/null +++ b/sdk/nodejs/postgresflexDatabase.ts @@ -0,0 +1,161 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class PostgresflexDatabase extends pulumi.CustomResource { + /** + * Get an existing PostgresflexDatabase 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?: PostgresflexDatabaseState, opts?: pulumi.CustomResourceOptions): PostgresflexDatabase { + return new PostgresflexDatabase(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/postgresflexDatabase:PostgresflexDatabase'; + + /** + * Returns true if the given object is an instance of PostgresflexDatabase. 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 PostgresflexDatabase { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === PostgresflexDatabase.__pulumiType; + } + + /** + * Database ID. + */ + public /*out*/ readonly databaseId!: pulumi.Output; + /** + * ID of the Postgres Flex instance. + */ + public readonly instanceId!: pulumi.Output; + /** + * Database name. + */ + public readonly name!: pulumi.Output; + /** + * Username of the database owner. + */ + public readonly owner!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + + /** + * Create a PostgresflexDatabase 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: PostgresflexDatabaseArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: PostgresflexDatabaseArgs | PostgresflexDatabaseState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as PostgresflexDatabaseState | undefined; + resourceInputs["databaseId"] = state ? state.databaseId : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["owner"] = state ? state.owner : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + } else { + const args = argsOrState as PostgresflexDatabaseArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.owner === undefined) && !opts.urn) { + throw new Error("Missing required property 'owner'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["owner"] = args ? args.owner : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["databaseId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(PostgresflexDatabase.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering PostgresflexDatabase resources. + */ +export interface PostgresflexDatabaseState { + /** + * Database ID. + */ + databaseId?: pulumi.Input; + /** + * ID of the Postgres Flex instance. + */ + instanceId?: pulumi.Input; + /** + * Database name. + */ + name?: pulumi.Input; + /** + * Username of the database owner. + */ + owner?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} + +/** + * The set of arguments for constructing a PostgresflexDatabase resource. + */ +export interface PostgresflexDatabaseArgs { + /** + * ID of the Postgres Flex instance. + */ + instanceId: pulumi.Input; + /** + * Database name. + */ + name?: pulumi.Input; + /** + * Username of the database owner. + */ + owner: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/postgresflexInstance.ts b/sdk/nodejs/postgresflexInstance.ts new file mode 100644 index 0000000..350d463 --- /dev/null +++ b/sdk/nodejs/postgresflexInstance.ts @@ -0,0 +1,186 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class PostgresflexInstance extends pulumi.CustomResource { + /** + * Get an existing PostgresflexInstance 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?: PostgresflexInstanceState, opts?: pulumi.CustomResourceOptions): PostgresflexInstance { + return new PostgresflexInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/postgresflexInstance:PostgresflexInstance'; + + /** + * Returns true if the given object is an instance of PostgresflexInstance. 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 PostgresflexInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === PostgresflexInstance.__pulumiType; + } + + /** + * The Access Control List (ACL) for the PostgresFlex instance. + */ + public readonly acls!: pulumi.Output; + public readonly backupSchedule!: pulumi.Output; + public readonly flavor!: pulumi.Output; + /** + * ID of the PostgresFlex instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + public readonly replicas!: pulumi.Output; + public readonly storage!: pulumi.Output; + public readonly version!: pulumi.Output; + + /** + * Create a PostgresflexInstance 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: PostgresflexInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: PostgresflexInstanceArgs | PostgresflexInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as PostgresflexInstanceState | undefined; + resourceInputs["acls"] = state ? state.acls : undefined; + resourceInputs["backupSchedule"] = state ? state.backupSchedule : undefined; + resourceInputs["flavor"] = state ? state.flavor : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["replicas"] = state ? state.replicas : undefined; + resourceInputs["storage"] = state ? state.storage : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as PostgresflexInstanceArgs | undefined; + if ((!args || args.acls === undefined) && !opts.urn) { + throw new Error("Missing required property 'acls'"); + } + if ((!args || args.backupSchedule === undefined) && !opts.urn) { + throw new Error("Missing required property 'backupSchedule'"); + } + if ((!args || args.flavor === undefined) && !opts.urn) { + throw new Error("Missing required property 'flavor'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.replicas === undefined) && !opts.urn) { + throw new Error("Missing required property 'replicas'"); + } + if ((!args || args.storage === undefined) && !opts.urn) { + throw new Error("Missing required property 'storage'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["acls"] = args ? args.acls : undefined; + resourceInputs["backupSchedule"] = args ? args.backupSchedule : undefined; + resourceInputs["flavor"] = args ? args.flavor : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["replicas"] = args ? args.replicas : undefined; + resourceInputs["storage"] = args ? args.storage : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["instanceId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(PostgresflexInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering PostgresflexInstance resources. + */ +export interface PostgresflexInstanceState { + /** + * The Access Control List (ACL) for the PostgresFlex instance. + */ + acls?: pulumi.Input[]>; + backupSchedule?: pulumi.Input; + flavor?: pulumi.Input; + /** + * ID of the PostgresFlex instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + replicas?: pulumi.Input; + storage?: pulumi.Input; + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a PostgresflexInstance resource. + */ +export interface PostgresflexInstanceArgs { + /** + * The Access Control List (ACL) for the PostgresFlex instance. + */ + acls: pulumi.Input[]>; + backupSchedule: pulumi.Input; + flavor: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + replicas: pulumi.Input; + storage: pulumi.Input; + version: pulumi.Input; +} diff --git a/sdk/nodejs/postgresflexUser.ts b/sdk/nodejs/postgresflexUser.ts new file mode 100644 index 0000000..d675b86 --- /dev/null +++ b/sdk/nodejs/postgresflexUser.ts @@ -0,0 +1,173 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Postgres Flex user resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class PostgresflexUser extends pulumi.CustomResource { + /** + * Get an existing PostgresflexUser 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?: PostgresflexUserState, opts?: pulumi.CustomResourceOptions): PostgresflexUser { + return new PostgresflexUser(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/postgresflexUser:PostgresflexUser'; + + /** + * Returns true if the given object is an instance of PostgresflexUser. 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 PostgresflexUser { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === PostgresflexUser.__pulumiType; + } + + public /*out*/ readonly host!: pulumi.Output; + /** + * ID of the PostgresFlex instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * Database access levels for the user. Supported values are: `login`, `createdb`. + */ + public readonly roles!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + /** + * User ID. + */ + public /*out*/ readonly userId!: pulumi.Output; + public readonly username!: pulumi.Output; + + /** + * Create a PostgresflexUser 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: PostgresflexUserArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: PostgresflexUserArgs | PostgresflexUserState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as PostgresflexUserState | undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["roles"] = state ? state.roles : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["userId"] = state ? state.userId : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as PostgresflexUserArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.roles === undefined) && !opts.urn) { + throw new Error("Missing required property 'roles'"); + } + if ((!args || args.username === undefined) && !opts.urn) { + throw new Error("Missing required property 'username'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["roles"] = args ? args.roles : undefined; + resourceInputs["username"] = args ? args.username : undefined; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["userId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(PostgresflexUser.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering PostgresflexUser resources. + */ +export interface PostgresflexUserState { + host?: pulumi.Input; + /** + * ID of the PostgresFlex instance. + */ + instanceId?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Database access levels for the user. Supported values are: `login`, `createdb`. + */ + roles?: pulumi.Input[]>; + uri?: pulumi.Input; + /** + * User ID. + */ + userId?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a PostgresflexUser resource. + */ +export interface PostgresflexUserArgs { + /** + * ID of the PostgresFlex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Database access levels for the user. Supported values are: `login`, `createdb`. + */ + roles: pulumi.Input[]>; + username: pulumi.Input; +} diff --git a/sdk/nodejs/provider.ts b/sdk/nodejs/provider.ts new file mode 100644 index 0000000..111eb48 --- /dev/null +++ b/sdk/nodejs/provider.ts @@ -0,0 +1,417 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * The provider type for the stackit package. By default, resources use package-wide configuration + * settings, however an explicit `Provider` instance may be created and passed during resource + * construction to achieve fine-grained programmatic control over provider settings. See the + * [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + */ +export class Provider extends pulumi.ProviderResource { + /** @internal */ + public static readonly __pulumiType = 'stackit'; + + /** + * Returns true if the given object is an instance of Provider. 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 Provider { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === "pulumi:providers:" + Provider.__pulumiType; + } + + /** + * Custom endpoint for the Argus service + * + * @deprecated Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. + */ + public readonly argusCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Membership service + */ + public readonly authorizationCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the CDN service + */ + public readonly cdnCustomEndpoint!: pulumi.Output; + /** + * Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + * value is `~/.stackit/credentials.json`. + */ + public readonly credentialsPath!: pulumi.Output; + /** + * Region will be used as the default location for regional services. Not all services require a region, some are global + */ + public readonly defaultRegion!: pulumi.Output; + /** + * Custom endpoint for the DNS service + */ + public readonly dnsCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Git service + */ + public readonly gitCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the IaaS service + */ + public readonly iaasCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Load Balancer service + */ + public readonly loadbalancerCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the LogMe service + */ + public readonly logmeCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the MariaDB service + */ + public readonly mariadbCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the AI Model Serving service + */ + public readonly modelservingCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the MongoDB Flex service + */ + public readonly mongodbflexCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Object Storage service + */ + public readonly objectstorageCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Observability service + */ + public readonly observabilityCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the OpenSearch service + */ + public readonly opensearchCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the PostgresFlex service + */ + public readonly postgresflexCustomEndpoint!: pulumi.Output; + /** + * Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + * included in the service account key. + */ + public readonly privateKey!: pulumi.Output; + /** + * Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + * key that is included in the service account key. + */ + public readonly privateKeyPath!: pulumi.Output; + /** + * Custom endpoint for the RabbitMQ service + */ + public readonly rabbitmqCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Redis service + */ + public readonly redisCustomEndpoint!: pulumi.Output; + /** + * Region will be used as the default location for regional services. Not all services require a region, some are global + * + * @deprecated This attribute is deprecated. Use 'default_region' instead + */ + public readonly region!: pulumi.Output; + /** + * Custom endpoint for the Resource Manager service + */ + public readonly resourcemanagerCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Secrets Manager service + */ + public readonly secretsmanagerCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Server Backup service + */ + public readonly serverBackupCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Server Update service + */ + public readonly serverUpdateCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Service Account service + */ + public readonly serviceAccountCustomEndpoint!: pulumi.Output; + /** + * Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + * if you want to use the resource manager project resource. + * + * @deprecated The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. + */ + public readonly serviceAccountEmail!: pulumi.Output; + /** + * Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + */ + public readonly serviceAccountKey!: pulumi.Output; + /** + * Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + * operations. + */ + public readonly serviceAccountKeyPath!: pulumi.Output; + /** + * Token used for authentication. If set, the token flow will be used to authenticate all operations. + */ + public readonly serviceAccountToken!: pulumi.Output; + /** + * Custom endpoint for the Service Enablement API + */ + public readonly serviceEnablementCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the Kubernetes Engine (SKE) service + */ + public readonly skeCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the SQL Server Flex service + */ + public readonly sqlserverflexCustomEndpoint!: pulumi.Output; + /** + * Custom endpoint for the token API, which is used to request access tokens when using the key flow + */ + public readonly tokenCustomEndpoint!: pulumi.Output; + + /** + * Create a Provider 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?: ProviderArgs, opts?: pulumi.ResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + { + resourceInputs["argusCustomEndpoint"] = args ? args.argusCustomEndpoint : undefined; + resourceInputs["authorizationCustomEndpoint"] = args ? args.authorizationCustomEndpoint : undefined; + resourceInputs["cdnCustomEndpoint"] = args ? args.cdnCustomEndpoint : undefined; + resourceInputs["credentialsPath"] = args ? args.credentialsPath : undefined; + resourceInputs["defaultRegion"] = args ? args.defaultRegion : undefined; + resourceInputs["dnsCustomEndpoint"] = args ? args.dnsCustomEndpoint : undefined; + resourceInputs["enableBetaResources"] = pulumi.output(args ? args.enableBetaResources : undefined).apply(JSON.stringify); + resourceInputs["experiments"] = pulumi.output(args ? args.experiments : undefined).apply(JSON.stringify); + resourceInputs["gitCustomEndpoint"] = args ? args.gitCustomEndpoint : undefined; + resourceInputs["iaasCustomEndpoint"] = args ? args.iaasCustomEndpoint : undefined; + resourceInputs["loadbalancerCustomEndpoint"] = args ? args.loadbalancerCustomEndpoint : undefined; + resourceInputs["logmeCustomEndpoint"] = args ? args.logmeCustomEndpoint : undefined; + resourceInputs["mariadbCustomEndpoint"] = args ? args.mariadbCustomEndpoint : undefined; + resourceInputs["modelservingCustomEndpoint"] = args ? args.modelservingCustomEndpoint : undefined; + resourceInputs["mongodbflexCustomEndpoint"] = args ? args.mongodbflexCustomEndpoint : undefined; + resourceInputs["objectstorageCustomEndpoint"] = args ? args.objectstorageCustomEndpoint : undefined; + resourceInputs["observabilityCustomEndpoint"] = args ? args.observabilityCustomEndpoint : undefined; + resourceInputs["opensearchCustomEndpoint"] = args ? args.opensearchCustomEndpoint : undefined; + resourceInputs["postgresflexCustomEndpoint"] = args ? args.postgresflexCustomEndpoint : undefined; + resourceInputs["privateKey"] = args ? args.privateKey : undefined; + resourceInputs["privateKeyPath"] = args ? args.privateKeyPath : undefined; + resourceInputs["rabbitmqCustomEndpoint"] = args ? args.rabbitmqCustomEndpoint : undefined; + resourceInputs["redisCustomEndpoint"] = args ? args.redisCustomEndpoint : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["resourcemanagerCustomEndpoint"] = args ? args.resourcemanagerCustomEndpoint : undefined; + resourceInputs["secretsmanagerCustomEndpoint"] = args ? args.secretsmanagerCustomEndpoint : undefined; + resourceInputs["serverBackupCustomEndpoint"] = args ? args.serverBackupCustomEndpoint : undefined; + resourceInputs["serverUpdateCustomEndpoint"] = args ? args.serverUpdateCustomEndpoint : undefined; + resourceInputs["serviceAccountCustomEndpoint"] = args ? args.serviceAccountCustomEndpoint : undefined; + resourceInputs["serviceAccountEmail"] = args ? args.serviceAccountEmail : undefined; + resourceInputs["serviceAccountKey"] = args ? args.serviceAccountKey : undefined; + resourceInputs["serviceAccountKeyPath"] = args ? args.serviceAccountKeyPath : undefined; + resourceInputs["serviceAccountToken"] = args ? args.serviceAccountToken : undefined; + resourceInputs["serviceEnablementCustomEndpoint"] = args ? args.serviceEnablementCustomEndpoint : undefined; + resourceInputs["skeCustomEndpoint"] = args ? args.skeCustomEndpoint : undefined; + resourceInputs["sqlserverflexCustomEndpoint"] = args ? args.sqlserverflexCustomEndpoint : undefined; + resourceInputs["tokenCustomEndpoint"] = args ? args.tokenCustomEndpoint : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Provider.__pulumiType, name, resourceInputs, opts); + } + + /** + * This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. + */ + terraformConfig(): pulumi.Output { + return pulumi.runtime.call("pulumi:providers:stackit/terraformConfig", { + "__self__": this, + }, this); + } +} + +/** + * The set of arguments for constructing a Provider resource. + */ +export interface ProviderArgs { + /** + * Custom endpoint for the Argus service + * + * @deprecated Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observabilityCustomEndpoint` and `observability` resources instead, which offer the exact same functionality. + */ + argusCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Membership service + */ + authorizationCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the CDN service + */ + cdnCustomEndpoint?: pulumi.Input; + /** + * Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + * value is `~/.stackit/credentials.json`. + */ + credentialsPath?: pulumi.Input; + /** + * Region will be used as the default location for regional services. Not all services require a region, some are global + */ + defaultRegion?: pulumi.Input; + /** + * Custom endpoint for the DNS service + */ + dnsCustomEndpoint?: pulumi.Input; + /** + * Enable beta resources. Default is false. + */ + enableBetaResources?: pulumi.Input; + /** + * Enables experiments. These are unstable features without official support. More information can be found in the README. + * Available Experiments: [iam] + */ + experiments?: pulumi.Input[]>; + /** + * Custom endpoint for the Git service + */ + gitCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the IaaS service + */ + iaasCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Load Balancer service + */ + loadbalancerCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the LogMe service + */ + logmeCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the MariaDB service + */ + mariadbCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the AI Model Serving service + */ + modelservingCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the MongoDB Flex service + */ + mongodbflexCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Object Storage service + */ + objectstorageCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Observability service + */ + observabilityCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the OpenSearch service + */ + opensearchCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the PostgresFlex service + */ + postgresflexCustomEndpoint?: pulumi.Input; + /** + * Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + * included in the service account key. + */ + privateKey?: pulumi.Input; + /** + * Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + * key that is included in the service account key. + */ + privateKeyPath?: pulumi.Input; + /** + * Custom endpoint for the RabbitMQ service + */ + rabbitmqCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Redis service + */ + redisCustomEndpoint?: pulumi.Input; + /** + * Region will be used as the default location for regional services. Not all services require a region, some are global + * + * @deprecated This attribute is deprecated. Use 'default_region' instead + */ + region?: pulumi.Input; + /** + * Custom endpoint for the Resource Manager service + */ + resourcemanagerCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Secrets Manager service + */ + secretsmanagerCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Server Backup service + */ + serverBackupCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Server Update service + */ + serverUpdateCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Service Account service + */ + serviceAccountCustomEndpoint?: pulumi.Input; + /** + * Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + * if you want to use the resource manager project resource. + * + * @deprecated The `serviceAccountEmail` field has been deprecated because it is not required. Will be removed after June 12th 2025. + */ + serviceAccountEmail?: pulumi.Input; + /** + * Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + */ + serviceAccountKey?: pulumi.Input; + /** + * Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + * operations. + */ + serviceAccountKeyPath?: pulumi.Input; + /** + * Token used for authentication. If set, the token flow will be used to authenticate all operations. + */ + serviceAccountToken?: pulumi.Input; + /** + * Custom endpoint for the Service Enablement API + */ + serviceEnablementCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the Kubernetes Engine (SKE) service + */ + skeCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the SQL Server Flex service + */ + sqlserverflexCustomEndpoint?: pulumi.Input; + /** + * Custom endpoint for the token API, which is used to request access tokens when using the key flow + */ + tokenCustomEndpoint?: pulumi.Input; +} + +export namespace Provider { + /** + * The results of the Provider.terraformConfig method. + */ + export interface TerraformConfigResult { + readonly result: {[key: string]: any}; + } + +} diff --git a/sdk/nodejs/publicIp.ts b/sdk/nodejs/publicIp.ts new file mode 100644 index 0000000..8d1e519 --- /dev/null +++ b/sdk/nodejs/publicIp.ts @@ -0,0 +1,128 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Public IP resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class PublicIp extends pulumi.CustomResource { + /** + * Get an existing PublicIp 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?: PublicIpState, opts?: pulumi.CustomResourceOptions): PublicIp { + return new PublicIp(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/publicIp:PublicIp'; + + /** + * Returns true if the given object is an instance of PublicIp. 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 PublicIp { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === PublicIp.__pulumiType; + } + + /** + * The IP address. + */ + public /*out*/ readonly ip!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + public readonly networkInterfaceId!: pulumi.Output; + /** + * STACKIT project ID to which the public IP is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The public IP ID. + */ + public /*out*/ readonly publicIpId!: pulumi.Output; + + /** + * Create a PublicIp 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: PublicIpArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: PublicIpArgs | PublicIpState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as PublicIpState | undefined; + resourceInputs["ip"] = state ? state.ip : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["networkInterfaceId"] = state ? state.networkInterfaceId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["publicIpId"] = state ? state.publicIpId : undefined; + } else { + const args = argsOrState as PublicIpArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["networkInterfaceId"] = args ? args.networkInterfaceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["ip"] = undefined /*out*/; + resourceInputs["publicIpId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(PublicIp.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering PublicIp resources. + */ +export interface PublicIpState { + /** + * The IP address. + */ + ip?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + networkInterfaceId?: pulumi.Input; + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId?: pulumi.Input; + /** + * The public IP ID. + */ + publicIpId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a PublicIp resource. + */ +export interface PublicIpArgs { + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + networkInterfaceId?: pulumi.Input; + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/publicIpAssociate.ts b/sdk/nodejs/publicIpAssociate.ts new file mode 100644 index 0000000..c2fa728 --- /dev/null +++ b/sdk/nodejs/publicIpAssociate.ts @@ -0,0 +1,136 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `stackit.PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration. + * + * !> The `stackit.PublicIpAssociate` resource should not be used together with the `stackit.PublicIp` resource for the same public IP or for the same network interface. + * Using both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association. + * + * ## Example Usage + */ +export class PublicIpAssociate extends pulumi.CustomResource { + /** + * Get an existing PublicIpAssociate 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?: PublicIpAssociateState, opts?: pulumi.CustomResourceOptions): PublicIpAssociate { + return new PublicIpAssociate(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/publicIpAssociate:PublicIpAssociate'; + + /** + * Returns true if the given object is an instance of PublicIpAssociate. 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 PublicIpAssociate { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === PublicIpAssociate.__pulumiType; + } + + /** + * The IP address. + */ + public /*out*/ readonly ip!: pulumi.Output; + /** + * The ID of the network interface (or virtual IP) to which the public IP should be attached to. + */ + public readonly networkInterfaceId!: pulumi.Output; + /** + * STACKIT project ID to which the public IP is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The public IP ID. + */ + public readonly publicIpId!: pulumi.Output; + + /** + * Create a PublicIpAssociate 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: PublicIpAssociateArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: PublicIpAssociateArgs | PublicIpAssociateState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as PublicIpAssociateState | undefined; + resourceInputs["ip"] = state ? state.ip : undefined; + resourceInputs["networkInterfaceId"] = state ? state.networkInterfaceId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["publicIpId"] = state ? state.publicIpId : undefined; + } else { + const args = argsOrState as PublicIpAssociateArgs | undefined; + if ((!args || args.networkInterfaceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'networkInterfaceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.publicIpId === undefined) && !opts.urn) { + throw new Error("Missing required property 'publicIpId'"); + } + resourceInputs["networkInterfaceId"] = args ? args.networkInterfaceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["publicIpId"] = args ? args.publicIpId : undefined; + resourceInputs["ip"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(PublicIpAssociate.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering PublicIpAssociate resources. + */ +export interface PublicIpAssociateState { + /** + * The IP address. + */ + ip?: pulumi.Input; + /** + * The ID of the network interface (or virtual IP) to which the public IP should be attached to. + */ + networkInterfaceId?: pulumi.Input; + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId?: pulumi.Input; + /** + * The public IP ID. + */ + publicIpId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a PublicIpAssociate resource. + */ +export interface PublicIpAssociateArgs { + /** + * The ID of the network interface (or virtual IP) to which the public IP should be attached to. + */ + networkInterfaceId: pulumi.Input; + /** + * STACKIT project ID to which the public IP is associated. + */ + projectId: pulumi.Input; + /** + * The public IP ID. + */ + publicIpId: pulumi.Input; +} diff --git a/sdk/nodejs/rabbitmqCredential.ts b/sdk/nodejs/rabbitmqCredential.ts new file mode 100644 index 0000000..c9de672 --- /dev/null +++ b/sdk/nodejs/rabbitmqCredential.ts @@ -0,0 +1,158 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class RabbitmqCredential extends pulumi.CustomResource { + /** + * Get an existing RabbitmqCredential 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?: RabbitmqCredentialState, opts?: pulumi.CustomResourceOptions): RabbitmqCredential { + return new RabbitmqCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/rabbitmqCredential:RabbitmqCredential'; + + /** + * Returns true if the given object is an instance of RabbitmqCredential. 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 RabbitmqCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === RabbitmqCredential.__pulumiType; + } + + /** + * The credential's ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + public /*out*/ readonly hosts!: pulumi.Output; + public /*out*/ readonly httpApiUri!: pulumi.Output; + public /*out*/ readonly httpApiUris!: pulumi.Output; + /** + * ID of the RabbitMQ instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly management!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public /*out*/ readonly uri!: pulumi.Output; + public /*out*/ readonly uris!: pulumi.Output; + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a RabbitmqCredential 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: RabbitmqCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: RabbitmqCredentialArgs | RabbitmqCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as RabbitmqCredentialState | undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["hosts"] = state ? state.hosts : undefined; + resourceInputs["httpApiUri"] = state ? state.httpApiUri : undefined; + resourceInputs["httpApiUris"] = state ? state.httpApiUris : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["management"] = state ? state.management : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["uris"] = state ? state.uris : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as RabbitmqCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["hosts"] = undefined /*out*/; + resourceInputs["httpApiUri"] = undefined /*out*/; + resourceInputs["httpApiUris"] = undefined /*out*/; + resourceInputs["management"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["uris"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(RabbitmqCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering RabbitmqCredential resources. + */ +export interface RabbitmqCredentialState { + /** + * The credential's ID. + */ + credentialId?: pulumi.Input; + host?: pulumi.Input; + hosts?: pulumi.Input[]>; + httpApiUri?: pulumi.Input; + httpApiUris?: pulumi.Input[]>; + /** + * ID of the RabbitMQ instance. + */ + instanceId?: pulumi.Input; + management?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + uri?: pulumi.Input; + uris?: pulumi.Input[]>; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a RabbitmqCredential resource. + */ +export interface RabbitmqCredentialArgs { + /** + * ID of the RabbitMQ instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/rabbitmqInstance.ts b/sdk/nodejs/rabbitmqInstance.ts new file mode 100644 index 0000000..cc861e5 --- /dev/null +++ b/sdk/nodejs/rabbitmqInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class RabbitmqInstance extends pulumi.CustomResource { + /** + * Get an existing RabbitmqInstance 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?: RabbitmqInstanceState, opts?: pulumi.CustomResourceOptions): RabbitmqInstance { + return new RabbitmqInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/rabbitmqInstance:RabbitmqInstance'; + + /** + * Returns true if the given object is an instance of RabbitmqInstance. 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 RabbitmqInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === RabbitmqInstance.__pulumiType; + } + + public /*out*/ readonly cfGuid!: pulumi.Output; + public /*out*/ readonly cfOrganizationGuid!: pulumi.Output; + public /*out*/ readonly cfSpaceGuid!: pulumi.Output; + public /*out*/ readonly dashboardUrl!: pulumi.Output; + public /*out*/ readonly imageUrl!: pulumi.Output; + /** + * ID of the RabbitMQ instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly parameters!: pulumi.Output; + /** + * The selected plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * The selected plan name. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The service version. + */ + public readonly version!: pulumi.Output; + + /** + * Create a RabbitmqInstance 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: RabbitmqInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: RabbitmqInstanceArgs | RabbitmqInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as RabbitmqInstanceState | undefined; + resourceInputs["cfGuid"] = state ? state.cfGuid : undefined; + resourceInputs["cfOrganizationGuid"] = state ? state.cfOrganizationGuid : undefined; + resourceInputs["cfSpaceGuid"] = state ? state.cfSpaceGuid : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["imageUrl"] = state ? state.imageUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as RabbitmqInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["cfGuid"] = undefined /*out*/; + resourceInputs["cfOrganizationGuid"] = undefined /*out*/; + resourceInputs["cfSpaceGuid"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["imageUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(RabbitmqInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering RabbitmqInstance resources. + */ +export interface RabbitmqInstanceState { + cfGuid?: pulumi.Input; + cfOrganizationGuid?: pulumi.Input; + cfSpaceGuid?: pulumi.Input; + dashboardUrl?: pulumi.Input; + imageUrl?: pulumi.Input; + /** + * ID of the RabbitMQ instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan ID. + */ + planId?: pulumi.Input; + /** + * The selected plan name. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The service version. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a RabbitmqInstance resource. + */ +export interface RabbitmqInstanceArgs { + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan name. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The service version. + */ + version: pulumi.Input; +} diff --git a/sdk/nodejs/redisCredential.ts b/sdk/nodejs/redisCredential.ts new file mode 100644 index 0000000..7ae08de --- /dev/null +++ b/sdk/nodejs/redisCredential.ts @@ -0,0 +1,152 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Redis credential resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class RedisCredential extends pulumi.CustomResource { + /** + * Get an existing RedisCredential 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?: RedisCredentialState, opts?: pulumi.CustomResourceOptions): RedisCredential { + return new RedisCredential(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/redisCredential:RedisCredential'; + + /** + * Returns true if the given object is an instance of RedisCredential. 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 RedisCredential { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === RedisCredential.__pulumiType; + } + + /** + * The credential's ID. + */ + public /*out*/ readonly credentialId!: pulumi.Output; + public /*out*/ readonly host!: pulumi.Output; + public /*out*/ readonly hosts!: pulumi.Output; + /** + * ID of the Redis instance. + */ + public readonly instanceId!: pulumi.Output; + public /*out*/ readonly loadBalancedHost!: pulumi.Output; + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * Connection URI. + */ + public /*out*/ readonly uri!: pulumi.Output; + public /*out*/ readonly username!: pulumi.Output; + + /** + * Create a RedisCredential 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: RedisCredentialArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: RedisCredentialArgs | RedisCredentialState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as RedisCredentialState | undefined; + resourceInputs["credentialId"] = state ? state.credentialId : undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["hosts"] = state ? state.hosts : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["loadBalancedHost"] = state ? state.loadBalancedHost : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["uri"] = state ? state.uri : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as RedisCredentialArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["credentialId"] = undefined /*out*/; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["hosts"] = undefined /*out*/; + resourceInputs["loadBalancedHost"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["uri"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password", "uri"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(RedisCredential.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering RedisCredential resources. + */ +export interface RedisCredentialState { + /** + * The credential's ID. + */ + credentialId?: pulumi.Input; + host?: pulumi.Input; + hosts?: pulumi.Input[]>; + /** + * ID of the Redis instance. + */ + instanceId?: pulumi.Input; + loadBalancedHost?: pulumi.Input; + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * Connection URI. + */ + uri?: pulumi.Input; + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a RedisCredential resource. + */ +export interface RedisCredentialArgs { + /** + * ID of the Redis instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/redisInstance.ts b/sdk/nodejs/redisInstance.ts new file mode 100644 index 0000000..b1ac9e5 --- /dev/null +++ b/sdk/nodejs/redisInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Redis instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class RedisInstance extends pulumi.CustomResource { + /** + * Get an existing RedisInstance 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?: RedisInstanceState, opts?: pulumi.CustomResourceOptions): RedisInstance { + return new RedisInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/redisInstance:RedisInstance'; + + /** + * Returns true if the given object is an instance of RedisInstance. 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 RedisInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === RedisInstance.__pulumiType; + } + + public /*out*/ readonly cfGuid!: pulumi.Output; + public /*out*/ readonly cfOrganizationGuid!: pulumi.Output; + public /*out*/ readonly cfSpaceGuid!: pulumi.Output; + public /*out*/ readonly dashboardUrl!: pulumi.Output; + public /*out*/ readonly imageUrl!: pulumi.Output; + /** + * ID of the Redis instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly parameters!: pulumi.Output; + /** + * The selected plan ID. + */ + public /*out*/ readonly planId!: pulumi.Output; + /** + * The selected plan name. + */ + public readonly planName!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The service version. + */ + public readonly version!: pulumi.Output; + + /** + * Create a RedisInstance 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: RedisInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: RedisInstanceArgs | RedisInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as RedisInstanceState | undefined; + resourceInputs["cfGuid"] = state ? state.cfGuid : undefined; + resourceInputs["cfOrganizationGuid"] = state ? state.cfOrganizationGuid : undefined; + resourceInputs["cfSpaceGuid"] = state ? state.cfSpaceGuid : undefined; + resourceInputs["dashboardUrl"] = state ? state.dashboardUrl : undefined; + resourceInputs["imageUrl"] = state ? state.imageUrl : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["parameters"] = state ? state.parameters : undefined; + resourceInputs["planId"] = state ? state.planId : undefined; + resourceInputs["planName"] = state ? state.planName : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as RedisInstanceArgs | undefined; + if ((!args || args.planName === undefined) && !opts.urn) { + throw new Error("Missing required property 'planName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.version === undefined) && !opts.urn) { + throw new Error("Missing required property 'version'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["parameters"] = args ? args.parameters : undefined; + resourceInputs["planName"] = args ? args.planName : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["cfGuid"] = undefined /*out*/; + resourceInputs["cfOrganizationGuid"] = undefined /*out*/; + resourceInputs["cfSpaceGuid"] = undefined /*out*/; + resourceInputs["dashboardUrl"] = undefined /*out*/; + resourceInputs["imageUrl"] = undefined /*out*/; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["planId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(RedisInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering RedisInstance resources. + */ +export interface RedisInstanceState { + cfGuid?: pulumi.Input; + cfOrganizationGuid?: pulumi.Input; + cfSpaceGuid?: pulumi.Input; + dashboardUrl?: pulumi.Input; + imageUrl?: pulumi.Input; + /** + * ID of the Redis instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan ID. + */ + planId?: pulumi.Input; + /** + * The selected plan name. + */ + planName?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The service version. + */ + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a RedisInstance resource. + */ +export interface RedisInstanceArgs { + /** + * Instance name. + */ + name?: pulumi.Input; + parameters?: pulumi.Input; + /** + * The selected plan name. + */ + planName: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The service version. + */ + version: pulumi.Input; +} diff --git a/sdk/nodejs/resourcemanagerProject.ts b/sdk/nodejs/resourcemanagerProject.ts new file mode 100644 index 0000000..3b96ef9 --- /dev/null +++ b/sdk/nodejs/resourcemanagerProject.ts @@ -0,0 +1,152 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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 + */ +export class ResourcemanagerProject extends pulumi.CustomResource { + /** + * Get an existing ResourcemanagerProject 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?: ResourcemanagerProjectState, opts?: pulumi.CustomResourceOptions): ResourcemanagerProject { + return new ResourcemanagerProject(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/resourcemanagerProject:ResourcemanagerProject'; + + /** + * Returns true if the given object is an instance of ResourcemanagerProject. 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 ResourcemanagerProject { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ResourcemanagerProject.__pulumiType; + } + + /** + * Project container ID. Globally unique, user-friendly identifier. + */ + public /*out*/ readonly containerId!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * Project name. + */ + public readonly name!: pulumi.Output; + /** + * Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + */ + public readonly ownerEmail!: pulumi.Output; + /** + * Parent resource identifier. Both container ID (user-friendly) and UUID are supported + */ + public readonly parentContainerId!: pulumi.Output; + /** + * Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + */ + public /*out*/ readonly projectId!: pulumi.Output; + + /** + * Create a ResourcemanagerProject 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: ResourcemanagerProjectArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ResourcemanagerProjectArgs | ResourcemanagerProjectState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ResourcemanagerProjectState | undefined; + resourceInputs["containerId"] = state ? state.containerId : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["ownerEmail"] = state ? state.ownerEmail : undefined; + resourceInputs["parentContainerId"] = state ? state.parentContainerId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + } else { + const args = argsOrState as ResourcemanagerProjectArgs | undefined; + if ((!args || args.ownerEmail === undefined) && !opts.urn) { + throw new Error("Missing required property 'ownerEmail'"); + } + if ((!args || args.parentContainerId === undefined) && !opts.urn) { + throw new Error("Missing required property 'parentContainerId'"); + } + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["ownerEmail"] = args ? args.ownerEmail : undefined; + resourceInputs["parentContainerId"] = args ? args.parentContainerId : undefined; + resourceInputs["containerId"] = undefined /*out*/; + resourceInputs["projectId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ResourcemanagerProject.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ResourcemanagerProject resources. + */ +export interface ResourcemanagerProjectState { + /** + * Project container ID. Globally unique, user-friendly identifier. + */ + containerId?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Project name. + */ + name?: pulumi.Input; + /** + * Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + */ + ownerEmail?: pulumi.Input; + /** + * Parent resource identifier. Both container ID (user-friendly) and UUID are supported + */ + parentContainerId?: pulumi.Input; + /** + * Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + */ + projectId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ResourcemanagerProject resource. + */ +export interface ResourcemanagerProjectArgs { + /** + * Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Project name. + */ + name?: pulumi.Input; + /** + * Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + */ + ownerEmail: pulumi.Input; + /** + * Parent resource identifier. Both container ID (user-friendly) and UUID are supported + */ + parentContainerId: pulumi.Input; +} diff --git a/sdk/nodejs/secretsmanagerInstance.ts b/sdk/nodejs/secretsmanagerInstance.ts new file mode 100644 index 0000000..69c7cf8 --- /dev/null +++ b/sdk/nodejs/secretsmanagerInstance.ts @@ -0,0 +1,127 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SecretsmanagerInstance extends pulumi.CustomResource { + /** + * Get an existing SecretsmanagerInstance 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?: SecretsmanagerInstanceState, opts?: pulumi.CustomResourceOptions): SecretsmanagerInstance { + return new SecretsmanagerInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/secretsmanagerInstance:SecretsmanagerInstance'; + + /** + * Returns true if the given object is an instance of SecretsmanagerInstance. 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 SecretsmanagerInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SecretsmanagerInstance.__pulumiType; + } + + /** + * The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + */ + public readonly acls!: pulumi.Output; + /** + * ID of the Secrets Manager instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + + /** + * Create a SecretsmanagerInstance 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: SecretsmanagerInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SecretsmanagerInstanceArgs | SecretsmanagerInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SecretsmanagerInstanceState | undefined; + resourceInputs["acls"] = state ? state.acls : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + } else { + const args = argsOrState as SecretsmanagerInstanceArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["acls"] = args ? args.acls : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["instanceId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(SecretsmanagerInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SecretsmanagerInstance resources. + */ +export interface SecretsmanagerInstanceState { + /** + * The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + */ + acls?: pulumi.Input[]>; + /** + * ID of the Secrets Manager instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SecretsmanagerInstance resource. + */ +export interface SecretsmanagerInstanceArgs { + /** + * The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + */ + acls?: pulumi.Input[]>; + /** + * Instance name. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/secretsmanagerUser.ts b/sdk/nodejs/secretsmanagerUser.ts new file mode 100644 index 0000000..dd23459 --- /dev/null +++ b/sdk/nodejs/secretsmanagerUser.ts @@ -0,0 +1,172 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Secrets Manager user resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SecretsmanagerUser extends pulumi.CustomResource { + /** + * Get an existing SecretsmanagerUser 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?: SecretsmanagerUserState, opts?: pulumi.CustomResourceOptions): SecretsmanagerUser { + return new SecretsmanagerUser(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/secretsmanagerUser:SecretsmanagerUser'; + + /** + * Returns true if the given object is an instance of SecretsmanagerUser. 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 SecretsmanagerUser { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SecretsmanagerUser.__pulumiType; + } + + /** + * A user chosen description to differentiate between multiple users. Can't be changed after creation. + */ + public readonly description!: pulumi.Output; + /** + * ID of the Secrets Manager instance. + */ + public readonly instanceId!: pulumi.Output; + /** + * An auto-generated password. + */ + public /*out*/ readonly password!: pulumi.Output; + /** + * STACKIT Project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The user's ID. + */ + public /*out*/ readonly userId!: pulumi.Output; + /** + * An auto-generated user name. + */ + public /*out*/ readonly username!: pulumi.Output; + /** + * If true, the user has writeaccess to the secrets engine. + */ + public readonly writeEnabled!: pulumi.Output; + + /** + * Create a SecretsmanagerUser 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: SecretsmanagerUserArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SecretsmanagerUserArgs | SecretsmanagerUserState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SecretsmanagerUserState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["userId"] = state ? state.userId : undefined; + resourceInputs["username"] = state ? state.username : undefined; + resourceInputs["writeEnabled"] = state ? state.writeEnabled : undefined; + } else { + const args = argsOrState as SecretsmanagerUserArgs | undefined; + if ((!args || args.description === undefined) && !opts.urn) { + throw new Error("Missing required property 'description'"); + } + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.writeEnabled === undefined) && !opts.urn) { + throw new Error("Missing required property 'writeEnabled'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["writeEnabled"] = args ? args.writeEnabled : undefined; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["userId"] = undefined /*out*/; + resourceInputs["username"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(SecretsmanagerUser.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SecretsmanagerUser resources. + */ +export interface SecretsmanagerUserState { + /** + * A user chosen description to differentiate between multiple users. Can't be changed after creation. + */ + description?: pulumi.Input; + /** + * ID of the Secrets Manager instance. + */ + instanceId?: pulumi.Input; + /** + * An auto-generated password. + */ + password?: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The user's ID. + */ + userId?: pulumi.Input; + /** + * An auto-generated user name. + */ + username?: pulumi.Input; + /** + * If true, the user has writeaccess to the secrets engine. + */ + writeEnabled?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SecretsmanagerUser resource. + */ +export interface SecretsmanagerUserArgs { + /** + * A user chosen description to differentiate between multiple users. Can't be changed after creation. + */ + description: pulumi.Input; + /** + * ID of the Secrets Manager instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT Project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * If true, the user has writeaccess to the secrets engine. + */ + writeEnabled: pulumi.Input; +} diff --git a/sdk/nodejs/securityGroup.ts b/sdk/nodejs/securityGroup.ts new file mode 100644 index 0000000..941748b --- /dev/null +++ b/sdk/nodejs/securityGroup.ts @@ -0,0 +1,155 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Security group resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SecurityGroup extends pulumi.CustomResource { + /** + * Get an existing SecurityGroup 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?: SecurityGroupState, opts?: pulumi.CustomResourceOptions): SecurityGroup { + return new SecurityGroup(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/securityGroup:SecurityGroup'; + + /** + * Returns true if the given object is an instance of SecurityGroup. 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 SecurityGroup { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SecurityGroup.__pulumiType; + } + + /** + * The description of the security group. + */ + public readonly description!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The name of the security group. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the security group is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The security group ID. + */ + public /*out*/ readonly securityGroupId!: pulumi.Output; + /** + * Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + */ + public readonly stateful!: pulumi.Output; + + /** + * Create a SecurityGroup 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: SecurityGroupArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SecurityGroupArgs | SecurityGroupState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SecurityGroupState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["securityGroupId"] = state ? state.securityGroupId : undefined; + resourceInputs["stateful"] = state ? state.stateful : undefined; + } else { + const args = argsOrState as SecurityGroupArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["stateful"] = args ? args.stateful : undefined; + resourceInputs["securityGroupId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(SecurityGroup.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SecurityGroup resources. + */ +export interface SecurityGroupState { + /** + * The description of the security group. + */ + description?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the security group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the security group is associated. + */ + projectId?: pulumi.Input; + /** + * The security group ID. + */ + securityGroupId?: pulumi.Input; + /** + * Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + */ + stateful?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SecurityGroup resource. + */ +export interface SecurityGroupArgs { + /** + * The description of the security group. + */ + description?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the security group. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the security group is associated. + */ + projectId: pulumi.Input; + /** + * Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + */ + stateful?: pulumi.Input; +} diff --git a/sdk/nodejs/securityGroupRule.ts b/sdk/nodejs/securityGroupRule.ts new file mode 100644 index 0000000..715f060 --- /dev/null +++ b/sdk/nodejs/securityGroupRule.ts @@ -0,0 +1,233 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Security group rule resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SecurityGroupRule extends pulumi.CustomResource { + /** + * Get an existing SecurityGroupRule 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?: SecurityGroupRuleState, opts?: pulumi.CustomResourceOptions): SecurityGroupRule { + return new SecurityGroupRule(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/securityGroupRule:SecurityGroupRule'; + + /** + * Returns true if the given object is an instance of SecurityGroupRule. 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 SecurityGroupRule { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SecurityGroupRule.__pulumiType; + } + + /** + * The rule description. + */ + public readonly description!: pulumi.Output; + /** + * The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + */ + public readonly direction!: pulumi.Output; + /** + * The ethertype which the rule should match. + */ + public readonly etherType!: pulumi.Output; + /** + * ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + */ + public readonly icmpParameters!: pulumi.Output; + /** + * The remote IP range which the rule should match. + */ + public readonly ipRange!: pulumi.Output; + /** + * The range of ports. This should only be provided if the protocol is not ICMP. + */ + public readonly portRange!: pulumi.Output; + /** + * STACKIT project ID to which the security group rule is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The internet protocol which the rule should match. + */ + public readonly protocol!: pulumi.Output; + /** + * The remote security group which the rule should match. + */ + public readonly remoteSecurityGroupId!: pulumi.Output; + /** + * The security group ID. + */ + public readonly securityGroupId!: pulumi.Output; + /** + * The security group rule ID. + */ + public /*out*/ readonly securityGroupRuleId!: pulumi.Output; + + /** + * Create a SecurityGroupRule 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: SecurityGroupRuleArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SecurityGroupRuleArgs | SecurityGroupRuleState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SecurityGroupRuleState | undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["direction"] = state ? state.direction : undefined; + resourceInputs["etherType"] = state ? state.etherType : undefined; + resourceInputs["icmpParameters"] = state ? state.icmpParameters : undefined; + resourceInputs["ipRange"] = state ? state.ipRange : undefined; + resourceInputs["portRange"] = state ? state.portRange : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["protocol"] = state ? state.protocol : undefined; + resourceInputs["remoteSecurityGroupId"] = state ? state.remoteSecurityGroupId : undefined; + resourceInputs["securityGroupId"] = state ? state.securityGroupId : undefined; + resourceInputs["securityGroupRuleId"] = state ? state.securityGroupRuleId : undefined; + } else { + const args = argsOrState as SecurityGroupRuleArgs | undefined; + if ((!args || args.direction === undefined) && !opts.urn) { + throw new Error("Missing required property 'direction'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.securityGroupId === undefined) && !opts.urn) { + throw new Error("Missing required property 'securityGroupId'"); + } + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["direction"] = args ? args.direction : undefined; + resourceInputs["etherType"] = args ? args.etherType : undefined; + resourceInputs["icmpParameters"] = args ? args.icmpParameters : undefined; + resourceInputs["ipRange"] = args ? args.ipRange : undefined; + resourceInputs["portRange"] = args ? args.portRange : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["protocol"] = args ? args.protocol : undefined; + resourceInputs["remoteSecurityGroupId"] = args ? args.remoteSecurityGroupId : undefined; + resourceInputs["securityGroupId"] = args ? args.securityGroupId : undefined; + resourceInputs["securityGroupRuleId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(SecurityGroupRule.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SecurityGroupRule resources. + */ +export interface SecurityGroupRuleState { + /** + * The rule description. + */ + description?: pulumi.Input; + /** + * The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + */ + direction?: pulumi.Input; + /** + * The ethertype which the rule should match. + */ + etherType?: pulumi.Input; + /** + * ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + */ + icmpParameters?: pulumi.Input; + /** + * The remote IP range which the rule should match. + */ + ipRange?: pulumi.Input; + /** + * The range of ports. This should only be provided if the protocol is not ICMP. + */ + portRange?: pulumi.Input; + /** + * STACKIT project ID to which the security group rule is associated. + */ + projectId?: pulumi.Input; + /** + * The internet protocol which the rule should match. + */ + protocol?: pulumi.Input; + /** + * The remote security group which the rule should match. + */ + remoteSecurityGroupId?: pulumi.Input; + /** + * The security group ID. + */ + securityGroupId?: pulumi.Input; + /** + * The security group rule ID. + */ + securityGroupRuleId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SecurityGroupRule resource. + */ +export interface SecurityGroupRuleArgs { + /** + * The rule description. + */ + description?: pulumi.Input; + /** + * The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + */ + direction: pulumi.Input; + /** + * The ethertype which the rule should match. + */ + etherType?: pulumi.Input; + /** + * ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + */ + icmpParameters?: pulumi.Input; + /** + * The remote IP range which the rule should match. + */ + ipRange?: pulumi.Input; + /** + * The range of ports. This should only be provided if the protocol is not ICMP. + */ + portRange?: pulumi.Input; + /** + * STACKIT project ID to which the security group rule is associated. + */ + projectId: pulumi.Input; + /** + * The internet protocol which the rule should match. + */ + protocol?: pulumi.Input; + /** + * The remote security group which the rule should match. + */ + remoteSecurityGroupId?: pulumi.Input; + /** + * The security group ID. + */ + securityGroupId: pulumi.Input; +} diff --git a/sdk/nodejs/server.ts b/sdk/nodejs/server.ts new file mode 100644 index 0000000..f7fdef1 --- /dev/null +++ b/sdk/nodejs/server.ts @@ -0,0 +1,300 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server resource schema. Must have a region specified in the provider configuration. + * + * ## Example Usage + * + * ### With key pair + * + * ### Boot from volume + * + * ### Boot from existing volume + * + * ### Network setup + * + * ### Server with attached volume + * + * ### Server with user data (cloud-init) + */ +export class Server extends pulumi.CustomResource { + /** + * Get an existing Server 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?: ServerState, opts?: pulumi.CustomResourceOptions): Server { + return new Server(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/server:Server'; + + /** + * Returns true if the given object is an instance of Server. 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 Server { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Server.__pulumiType; + } + + /** + * The affinity group the server is assigned to. + */ + public readonly affinityGroup!: pulumi.Output; + /** + * The availability zone of the server. + */ + public readonly availabilityZone!: pulumi.Output; + /** + * The boot volume for the server + */ + public readonly bootVolume!: pulumi.Output; + /** + * Date-time when the server was created + */ + public /*out*/ readonly createdAt!: pulumi.Output; + /** + * The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + */ + public readonly desiredStatus!: pulumi.Output; + /** + * The image ID to be used for an ephemeral disk on the server. + */ + public readonly imageId!: pulumi.Output; + /** + * The name of the keypair used during server creation. + */ + public readonly keypairName!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * Date-time when the server was launched + */ + public /*out*/ readonly launchedAt!: pulumi.Output; + /** + * Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + */ + public readonly machineType!: pulumi.Output; + /** + * The name of the server. + */ + public readonly name!: pulumi.Output; + /** + * The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + */ + public readonly networkInterfaces!: pulumi.Output; + /** + * STACKIT project ID to which the server is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The server ID. + */ + public /*out*/ readonly serverId!: pulumi.Output; + /** + * Date-time when the server was updated + */ + public /*out*/ readonly updatedAt!: pulumi.Output; + /** + * User data that is passed via cloud-init to the server. + */ + public readonly userData!: pulumi.Output; + + /** + * Create a Server 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: ServerArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerArgs | ServerState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerState | undefined; + resourceInputs["affinityGroup"] = state ? state.affinityGroup : undefined; + resourceInputs["availabilityZone"] = state ? state.availabilityZone : undefined; + resourceInputs["bootVolume"] = state ? state.bootVolume : undefined; + resourceInputs["createdAt"] = state ? state.createdAt : undefined; + resourceInputs["desiredStatus"] = state ? state.desiredStatus : undefined; + resourceInputs["imageId"] = state ? state.imageId : undefined; + resourceInputs["keypairName"] = state ? state.keypairName : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["launchedAt"] = state ? state.launchedAt : undefined; + resourceInputs["machineType"] = state ? state.machineType : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["networkInterfaces"] = state ? state.networkInterfaces : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + resourceInputs["updatedAt"] = state ? state.updatedAt : undefined; + resourceInputs["userData"] = state ? state.userData : undefined; + } else { + const args = argsOrState as ServerArgs | undefined; + if ((!args || args.machineType === undefined) && !opts.urn) { + throw new Error("Missing required property 'machineType'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["affinityGroup"] = args ? args.affinityGroup : undefined; + resourceInputs["availabilityZone"] = args ? args.availabilityZone : undefined; + resourceInputs["bootVolume"] = args ? args.bootVolume : undefined; + resourceInputs["desiredStatus"] = args ? args.desiredStatus : undefined; + resourceInputs["imageId"] = args ? args.imageId : undefined; + resourceInputs["keypairName"] = args ? args.keypairName : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["machineType"] = args ? args.machineType : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["networkInterfaces"] = args ? args.networkInterfaces : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["userData"] = args ? args.userData : undefined; + resourceInputs["createdAt"] = undefined /*out*/; + resourceInputs["launchedAt"] = undefined /*out*/; + resourceInputs["serverId"] = undefined /*out*/; + resourceInputs["updatedAt"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Server.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Server resources. + */ +export interface ServerState { + /** + * The affinity group the server is assigned to. + */ + affinityGroup?: pulumi.Input; + /** + * The availability zone of the server. + */ + availabilityZone?: pulumi.Input; + /** + * The boot volume for the server + */ + bootVolume?: pulumi.Input; + /** + * Date-time when the server was created + */ + createdAt?: pulumi.Input; + /** + * The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + */ + desiredStatus?: pulumi.Input; + /** + * The image ID to be used for an ephemeral disk on the server. + */ + imageId?: pulumi.Input; + /** + * The name of the keypair used during server creation. + */ + keypairName?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Date-time when the server was launched + */ + launchedAt?: pulumi.Input; + /** + * Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + */ + machineType?: pulumi.Input; + /** + * The name of the server. + */ + name?: pulumi.Input; + /** + * The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + */ + networkInterfaces?: pulumi.Input[]>; + /** + * STACKIT project ID to which the server is associated. + */ + projectId?: pulumi.Input; + /** + * The server ID. + */ + serverId?: pulumi.Input; + /** + * Date-time when the server was updated + */ + updatedAt?: pulumi.Input; + /** + * User data that is passed via cloud-init to the server. + */ + userData?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Server resource. + */ +export interface ServerArgs { + /** + * The affinity group the server is assigned to. + */ + affinityGroup?: pulumi.Input; + /** + * The availability zone of the server. + */ + availabilityZone?: pulumi.Input; + /** + * The boot volume for the server + */ + bootVolume?: pulumi.Input; + /** + * The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + */ + desiredStatus?: pulumi.Input; + /** + * The image ID to be used for an ephemeral disk on the server. + */ + imageId?: pulumi.Input; + /** + * The name of the keypair used during server creation. + */ + keypairName?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + */ + machineType: pulumi.Input; + /** + * The name of the server. + */ + name?: pulumi.Input; + /** + * The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + */ + networkInterfaces?: pulumi.Input[]>; + /** + * STACKIT project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * User data that is passed via cloud-init to the server. + */ + userData?: pulumi.Input; +} diff --git a/sdk/nodejs/serverBackupSchedule.ts b/sdk/nodejs/serverBackupSchedule.ts new file mode 100644 index 0000000..ebc3ec0 --- /dev/null +++ b/sdk/nodejs/serverBackupSchedule.ts @@ -0,0 +1,199 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server backup schedule resource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export class ServerBackupSchedule extends pulumi.CustomResource { + /** + * Get an existing ServerBackupSchedule 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?: ServerBackupScheduleState, opts?: pulumi.CustomResourceOptions): ServerBackupSchedule { + return new ServerBackupSchedule(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serverBackupSchedule:ServerBackupSchedule'; + + /** + * Returns true if the given object is an instance of ServerBackupSchedule. 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 ServerBackupSchedule { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServerBackupSchedule.__pulumiType; + } + + /** + * Backup schedule details for the backups. + */ + public readonly backupProperties!: pulumi.Output; + /** + * Backup schedule ID. + */ + public /*out*/ readonly backupScheduleId!: pulumi.Output; + /** + * Is the backup schedule enabled or disabled. + */ + public readonly enabled!: pulumi.Output; + /** + * The schedule name. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT Project ID to which the server is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * Backup schedule described in `rrule` (recurrence rule) format. + */ + public readonly rrule!: pulumi.Output; + /** + * Server ID for the backup schedule. + */ + public readonly serverId!: pulumi.Output; + + /** + * Create a ServerBackupSchedule 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: ServerBackupScheduleArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerBackupScheduleArgs | ServerBackupScheduleState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerBackupScheduleState | undefined; + resourceInputs["backupProperties"] = state ? state.backupProperties : undefined; + resourceInputs["backupScheduleId"] = state ? state.backupScheduleId : undefined; + resourceInputs["enabled"] = state ? state.enabled : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["rrule"] = state ? state.rrule : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + } else { + const args = argsOrState as ServerBackupScheduleArgs | undefined; + if ((!args || args.backupProperties === undefined) && !opts.urn) { + throw new Error("Missing required property 'backupProperties'"); + } + if ((!args || args.enabled === undefined) && !opts.urn) { + throw new Error("Missing required property 'enabled'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.rrule === undefined) && !opts.urn) { + throw new Error("Missing required property 'rrule'"); + } + if ((!args || args.serverId === undefined) && !opts.urn) { + throw new Error("Missing required property 'serverId'"); + } + resourceInputs["backupProperties"] = args ? args.backupProperties : undefined; + resourceInputs["enabled"] = args ? args.enabled : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["rrule"] = args ? args.rrule : undefined; + resourceInputs["serverId"] = args ? args.serverId : undefined; + resourceInputs["backupScheduleId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServerBackupSchedule.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServerBackupSchedule resources. + */ +export interface ServerBackupScheduleState { + /** + * Backup schedule details for the backups. + */ + backupProperties?: pulumi.Input; + /** + * Backup schedule ID. + */ + backupScheduleId?: pulumi.Input; + /** + * Is the backup schedule enabled or disabled. + */ + enabled?: pulumi.Input; + /** + * The schedule name. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Backup schedule described in `rrule` (recurrence rule) format. + */ + rrule?: pulumi.Input; + /** + * Server ID for the backup schedule. + */ + serverId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServerBackupSchedule resource. + */ +export interface ServerBackupScheduleArgs { + /** + * Backup schedule details for the backups. + */ + backupProperties: pulumi.Input; + /** + * Is the backup schedule enabled or disabled. + */ + enabled: pulumi.Input; + /** + * The schedule name. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Backup schedule described in `rrule` (recurrence rule) format. + */ + rrule: pulumi.Input; + /** + * Server ID for the backup schedule. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/serverNetworkInterfaceAttach.ts b/sdk/nodejs/serverNetworkInterfaceAttach.ts new file mode 100644 index 0000000..746fc31 --- /dev/null +++ b/sdk/nodejs/serverNetworkInterfaceAttach.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot. + * + * ## Example Usage + */ +export class ServerNetworkInterfaceAttach extends pulumi.CustomResource { + /** + * Get an existing ServerNetworkInterfaceAttach 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?: ServerNetworkInterfaceAttachState, opts?: pulumi.CustomResourceOptions): ServerNetworkInterfaceAttach { + return new ServerNetworkInterfaceAttach(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach'; + + /** + * Returns true if the given object is an instance of ServerNetworkInterfaceAttach. 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 ServerNetworkInterfaceAttach { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServerNetworkInterfaceAttach.__pulumiType; + } + + /** + * The network interface ID. + */ + public readonly networkInterfaceId!: pulumi.Output; + /** + * STACKIT project ID to which the network interface attachment is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The server ID. + */ + public readonly serverId!: pulumi.Output; + + /** + * Create a ServerNetworkInterfaceAttach 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: ServerNetworkInterfaceAttachArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerNetworkInterfaceAttachArgs | ServerNetworkInterfaceAttachState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerNetworkInterfaceAttachState | undefined; + resourceInputs["networkInterfaceId"] = state ? state.networkInterfaceId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + } else { + const args = argsOrState as ServerNetworkInterfaceAttachArgs | undefined; + if ((!args || args.networkInterfaceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'networkInterfaceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.serverId === undefined) && !opts.urn) { + throw new Error("Missing required property 'serverId'"); + } + resourceInputs["networkInterfaceId"] = args ? args.networkInterfaceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["serverId"] = args ? args.serverId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServerNetworkInterfaceAttach.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServerNetworkInterfaceAttach resources. + */ +export interface ServerNetworkInterfaceAttachState { + /** + * The network interface ID. + */ + networkInterfaceId?: pulumi.Input; + /** + * STACKIT project ID to which the network interface attachment is associated. + */ + projectId?: pulumi.Input; + /** + * The server ID. + */ + serverId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServerNetworkInterfaceAttach resource. + */ +export interface ServerNetworkInterfaceAttachArgs { + /** + * The network interface ID. + */ + networkInterfaceId: pulumi.Input; + /** + * STACKIT project ID to which the network interface attachment is associated. + */ + projectId: pulumi.Input; + /** + * The server ID. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/serverServiceAccountAttach.ts b/sdk/nodejs/serverServiceAccountAttach.ts new file mode 100644 index 0000000..48f9988 --- /dev/null +++ b/sdk/nodejs/serverServiceAccountAttach.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ServerServiceAccountAttach extends pulumi.CustomResource { + /** + * Get an existing ServerServiceAccountAttach 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?: ServerServiceAccountAttachState, opts?: pulumi.CustomResourceOptions): ServerServiceAccountAttach { + return new ServerServiceAccountAttach(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach'; + + /** + * Returns true if the given object is an instance of ServerServiceAccountAttach. 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 ServerServiceAccountAttach { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServerServiceAccountAttach.__pulumiType; + } + + /** + * STACKIT project ID to which the service account attachment is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The server ID. + */ + public readonly serverId!: pulumi.Output; + /** + * The service account email. + */ + public readonly serviceAccountEmail!: pulumi.Output; + + /** + * Create a ServerServiceAccountAttach 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: ServerServiceAccountAttachArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerServiceAccountAttachArgs | ServerServiceAccountAttachState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerServiceAccountAttachState | undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + resourceInputs["serviceAccountEmail"] = state ? state.serviceAccountEmail : undefined; + } else { + const args = argsOrState as ServerServiceAccountAttachArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.serverId === undefined) && !opts.urn) { + throw new Error("Missing required property 'serverId'"); + } + if ((!args || args.serviceAccountEmail === undefined) && !opts.urn) { + throw new Error("Missing required property 'serviceAccountEmail'"); + } + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["serverId"] = args ? args.serverId : undefined; + resourceInputs["serviceAccountEmail"] = args ? args.serviceAccountEmail : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServerServiceAccountAttach.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServerServiceAccountAttach resources. + */ +export interface ServerServiceAccountAttachState { + /** + * STACKIT project ID to which the service account attachment is associated. + */ + projectId?: pulumi.Input; + /** + * The server ID. + */ + serverId?: pulumi.Input; + /** + * The service account email. + */ + serviceAccountEmail?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServerServiceAccountAttach resource. + */ +export interface ServerServiceAccountAttachArgs { + /** + * STACKIT project ID to which the service account attachment is associated. + */ + projectId: pulumi.Input; + /** + * The server ID. + */ + serverId: pulumi.Input; + /** + * The service account email. + */ + serviceAccountEmail: pulumi.Input; +} diff --git a/sdk/nodejs/serverUpdateSchedule.ts b/sdk/nodejs/serverUpdateSchedule.ts new file mode 100644 index 0000000..a26403d --- /dev/null +++ b/sdk/nodejs/serverUpdateSchedule.ts @@ -0,0 +1,197 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Server update schedule resource schema. Must have a `region` specified in the provider configuration. + * + * > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + * + * ## Example Usage + */ +export class ServerUpdateSchedule extends pulumi.CustomResource { + /** + * Get an existing ServerUpdateSchedule 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?: ServerUpdateScheduleState, opts?: pulumi.CustomResourceOptions): ServerUpdateSchedule { + return new ServerUpdateSchedule(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serverUpdateSchedule:ServerUpdateSchedule'; + + /** + * Returns true if the given object is an instance of ServerUpdateSchedule. 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 ServerUpdateSchedule { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServerUpdateSchedule.__pulumiType; + } + + /** + * Is the update schedule enabled or disabled. + */ + public readonly enabled!: pulumi.Output; + /** + * Maintenance window [1..24]. + */ + public readonly maintenanceWindow!: pulumi.Output; + /** + * The schedule name. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT Project ID to which the server is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + /** + * Update schedule described in `rrule` (recurrence rule) format. + */ + public readonly rrule!: pulumi.Output; + /** + * Server ID for the update schedule. + */ + public readonly serverId!: pulumi.Output; + /** + * Update schedule ID. + */ + public /*out*/ readonly updateScheduleId!: pulumi.Output; + + /** + * Create a ServerUpdateSchedule 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: ServerUpdateScheduleArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerUpdateScheduleArgs | ServerUpdateScheduleState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerUpdateScheduleState | undefined; + resourceInputs["enabled"] = state ? state.enabled : undefined; + resourceInputs["maintenanceWindow"] = state ? state.maintenanceWindow : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["rrule"] = state ? state.rrule : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + resourceInputs["updateScheduleId"] = state ? state.updateScheduleId : undefined; + } else { + const args = argsOrState as ServerUpdateScheduleArgs | undefined; + if ((!args || args.enabled === undefined) && !opts.urn) { + throw new Error("Missing required property 'enabled'"); + } + if ((!args || args.maintenanceWindow === undefined) && !opts.urn) { + throw new Error("Missing required property 'maintenanceWindow'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.rrule === undefined) && !opts.urn) { + throw new Error("Missing required property 'rrule'"); + } + if ((!args || args.serverId === undefined) && !opts.urn) { + throw new Error("Missing required property 'serverId'"); + } + resourceInputs["enabled"] = args ? args.enabled : undefined; + resourceInputs["maintenanceWindow"] = args ? args.maintenanceWindow : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["rrule"] = args ? args.rrule : undefined; + resourceInputs["serverId"] = args ? args.serverId : undefined; + resourceInputs["updateScheduleId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServerUpdateSchedule.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServerUpdateSchedule resources. + */ +export interface ServerUpdateScheduleState { + /** + * Is the update schedule enabled or disabled. + */ + enabled?: pulumi.Input; + /** + * Maintenance window [1..24]. + */ + maintenanceWindow?: pulumi.Input; + /** + * The schedule name. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Update schedule described in `rrule` (recurrence rule) format. + */ + rrule?: pulumi.Input; + /** + * Server ID for the update schedule. + */ + serverId?: pulumi.Input; + /** + * Update schedule ID. + */ + updateScheduleId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServerUpdateSchedule resource. + */ +export interface ServerUpdateScheduleArgs { + /** + * Is the update schedule enabled or disabled. + */ + enabled: pulumi.Input; + /** + * Maintenance window [1..24]. + */ + maintenanceWindow: pulumi.Input; + /** + * The schedule name. + */ + name?: pulumi.Input; + /** + * STACKIT Project ID to which the server is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + /** + * Update schedule described in `rrule` (recurrence rule) format. + */ + rrule: pulumi.Input; + /** + * Server ID for the update schedule. + */ + serverId: pulumi.Input; +} diff --git a/sdk/nodejs/serverVolumeAttach.ts b/sdk/nodejs/serverVolumeAttach.ts new file mode 100644 index 0000000..f2ee2d9 --- /dev/null +++ b/sdk/nodejs/serverVolumeAttach.ts @@ -0,0 +1,123 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class ServerVolumeAttach extends pulumi.CustomResource { + /** + * Get an existing ServerVolumeAttach 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?: ServerVolumeAttachState, opts?: pulumi.CustomResourceOptions): ServerVolumeAttach { + return new ServerVolumeAttach(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serverVolumeAttach:ServerVolumeAttach'; + + /** + * Returns true if the given object is an instance of ServerVolumeAttach. 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 ServerVolumeAttach { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServerVolumeAttach.__pulumiType; + } + + /** + * STACKIT project ID to which the volume attachment is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The server ID. + */ + public readonly serverId!: pulumi.Output; + /** + * The volume ID. + */ + public readonly volumeId!: pulumi.Output; + + /** + * Create a ServerVolumeAttach 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: ServerVolumeAttachArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServerVolumeAttachArgs | ServerVolumeAttachState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServerVolumeAttachState | undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + resourceInputs["volumeId"] = state ? state.volumeId : undefined; + } else { + const args = argsOrState as ServerVolumeAttachArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.serverId === undefined) && !opts.urn) { + throw new Error("Missing required property 'serverId'"); + } + if ((!args || args.volumeId === undefined) && !opts.urn) { + throw new Error("Missing required property 'volumeId'"); + } + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["serverId"] = args ? args.serverId : undefined; + resourceInputs["volumeId"] = args ? args.volumeId : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServerVolumeAttach.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServerVolumeAttach resources. + */ +export interface ServerVolumeAttachState { + /** + * STACKIT project ID to which the volume attachment is associated. + */ + projectId?: pulumi.Input; + /** + * The server ID. + */ + serverId?: pulumi.Input; + /** + * The volume ID. + */ + volumeId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServerVolumeAttach resource. + */ +export interface ServerVolumeAttachArgs { + /** + * STACKIT project ID to which the volume attachment is associated. + */ + projectId: pulumi.Input; + /** + * The server ID. + */ + serverId: pulumi.Input; + /** + * The volume ID. + */ + volumeId: pulumi.Input; +} diff --git a/sdk/nodejs/serviceAccount.ts b/sdk/nodejs/serviceAccount.ts new file mode 100644 index 0000000..4429647 --- /dev/null +++ b/sdk/nodejs/serviceAccount.ts @@ -0,0 +1,113 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Service account resource schema. + * + * ## Example Usage + */ +export class ServiceAccount extends pulumi.CustomResource { + /** + * Get an existing ServiceAccount 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?: ServiceAccountState, opts?: pulumi.CustomResourceOptions): ServiceAccount { + return new ServiceAccount(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serviceAccount:ServiceAccount'; + + /** + * Returns true if the given object is an instance of ServiceAccount. 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 ServiceAccount { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServiceAccount.__pulumiType; + } + + /** + * Email of the service account. + */ + public /*out*/ readonly email!: pulumi.Output; + /** + * Name of the service account. + */ + public readonly name!: pulumi.Output; + /** + * STACKIT project ID to which the service account is associated. + */ + public readonly projectId!: pulumi.Output; + + /** + * Create a ServiceAccount 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: ServiceAccountArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServiceAccountArgs | ServiceAccountState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServiceAccountState | undefined; + resourceInputs["email"] = state ? state.email : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + } else { + const args = argsOrState as ServiceAccountArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["email"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(ServiceAccount.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServiceAccount resources. + */ +export interface ServiceAccountState { + /** + * Email of the service account. + */ + email?: pulumi.Input; + /** + * Name of the service account. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the service account is associated. + */ + projectId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServiceAccount resource. + */ +export interface ServiceAccountArgs { + /** + * Name of the service account. + */ + name?: pulumi.Input; + /** + * STACKIT project ID to which the service account is associated. + */ + projectId: pulumi.Input; +} diff --git a/sdk/nodejs/serviceAccountAccessToken.ts b/sdk/nodejs/serviceAccountAccessToken.ts new file mode 100644 index 0000000..c875966 --- /dev/null +++ b/sdk/nodejs/serviceAccountAccessToken.ts @@ -0,0 +1,187 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Service account access token schema. + * ## Example Usage + * + * ### Automatically rotate access tokens + */ +export class ServiceAccountAccessToken extends pulumi.CustomResource { + /** + * Get an existing ServiceAccountAccessToken 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?: ServiceAccountAccessTokenState, opts?: pulumi.CustomResourceOptions): ServiceAccountAccessToken { + return new ServiceAccountAccessToken(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken'; + + /** + * Returns true if the given object is an instance of ServiceAccountAccessToken. 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 ServiceAccountAccessToken { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServiceAccountAccessToken.__pulumiType; + } + + /** + * Identifier for the access token linked to the service account. + */ + public /*out*/ readonly accessTokenId!: pulumi.Output; + /** + * Indicate whether the token is currently active or inactive + */ + public /*out*/ readonly active!: pulumi.Output; + /** + * Timestamp indicating when the access token was created. + */ + public /*out*/ readonly createdAt!: pulumi.Output; + /** + * STACKIT project ID associated with the service account token. + */ + public readonly projectId!: pulumi.Output; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + public readonly rotateWhenChanged!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * Email address linked to the service account. + */ + public readonly serviceAccountEmail!: pulumi.Output; + /** + * JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + */ + public /*out*/ readonly token!: pulumi.Output; + /** + * Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + */ + public readonly ttlDays!: pulumi.Output; + /** + * Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + */ + public /*out*/ readonly validUntil!: pulumi.Output; + + /** + * Create a ServiceAccountAccessToken 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: ServiceAccountAccessTokenArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServiceAccountAccessTokenArgs | ServiceAccountAccessTokenState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServiceAccountAccessTokenState | undefined; + resourceInputs["accessTokenId"] = state ? state.accessTokenId : undefined; + resourceInputs["active"] = state ? state.active : undefined; + resourceInputs["createdAt"] = state ? state.createdAt : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["rotateWhenChanged"] = state ? state.rotateWhenChanged : undefined; + resourceInputs["serviceAccountEmail"] = state ? state.serviceAccountEmail : undefined; + resourceInputs["token"] = state ? state.token : undefined; + resourceInputs["ttlDays"] = state ? state.ttlDays : undefined; + resourceInputs["validUntil"] = state ? state.validUntil : undefined; + } else { + const args = argsOrState as ServiceAccountAccessTokenArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.serviceAccountEmail === undefined) && !opts.urn) { + throw new Error("Missing required property 'serviceAccountEmail'"); + } + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["rotateWhenChanged"] = args ? args.rotateWhenChanged : undefined; + resourceInputs["serviceAccountEmail"] = args ? args.serviceAccountEmail : undefined; + resourceInputs["ttlDays"] = args ? args.ttlDays : undefined; + resourceInputs["accessTokenId"] = undefined /*out*/; + resourceInputs["active"] = undefined /*out*/; + resourceInputs["createdAt"] = undefined /*out*/; + resourceInputs["token"] = undefined /*out*/; + resourceInputs["validUntil"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["token"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ServiceAccountAccessToken.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServiceAccountAccessToken resources. + */ +export interface ServiceAccountAccessTokenState { + /** + * Identifier for the access token linked to the service account. + */ + accessTokenId?: pulumi.Input; + /** + * Indicate whether the token is currently active or inactive + */ + active?: pulumi.Input; + /** + * Timestamp indicating when the access token was created. + */ + createdAt?: pulumi.Input; + /** + * STACKIT project ID associated with the service account token. + */ + projectId?: pulumi.Input; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Email address linked to the service account. + */ + serviceAccountEmail?: pulumi.Input; + /** + * JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + */ + token?: pulumi.Input; + /** + * Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + */ + ttlDays?: pulumi.Input; + /** + * Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + */ + validUntil?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServiceAccountAccessToken resource. + */ +export interface ServiceAccountAccessTokenArgs { + /** + * STACKIT project ID associated with the service account token. + */ + projectId: pulumi.Input; + /** + * A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Email address linked to the service account. + */ + serviceAccountEmail: pulumi.Input; + /** + * Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + */ + ttlDays?: pulumi.Input; +} diff --git a/sdk/nodejs/serviceAccountKey.ts b/sdk/nodejs/serviceAccountKey.ts new file mode 100644 index 0000000..2c00109 --- /dev/null +++ b/sdk/nodejs/serviceAccountKey.ts @@ -0,0 +1,171 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Service account key schema. + * ## Example Usage + * + * ### Automatically rotate service account keys + */ +export class ServiceAccountKey extends pulumi.CustomResource { + /** + * Get an existing ServiceAccountKey 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?: ServiceAccountKeyState, opts?: pulumi.CustomResourceOptions): ServiceAccountKey { + return new ServiceAccountKey(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/serviceAccountKey:ServiceAccountKey'; + + /** + * Returns true if the given object is an instance of ServiceAccountKey. 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 ServiceAccountKey { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === ServiceAccountKey.__pulumiType; + } + + /** + * The raw JSON representation of the service account key json, available for direct use. + */ + public /*out*/ readonly json!: pulumi.Output; + /** + * The unique identifier for the key associated with the service account. + */ + public /*out*/ readonly keyId!: pulumi.Output; + /** + * The STACKIT project ID associated with the service account key. + */ + public readonly projectId!: pulumi.Output; + /** + * Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + */ + public readonly publicKey!: pulumi.Output; + /** + * A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + */ + public readonly rotateWhenChanged!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The email address associated with the service account, used for account identification and communication. + */ + public readonly serviceAccountEmail!: pulumi.Output; + /** + * Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + */ + public readonly ttlDays!: pulumi.Output; + + /** + * Create a ServiceAccountKey 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: ServiceAccountKeyArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: ServiceAccountKeyArgs | ServiceAccountKeyState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as ServiceAccountKeyState | undefined; + resourceInputs["json"] = state ? state.json : undefined; + resourceInputs["keyId"] = state ? state.keyId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["publicKey"] = state ? state.publicKey : undefined; + resourceInputs["rotateWhenChanged"] = state ? state.rotateWhenChanged : undefined; + resourceInputs["serviceAccountEmail"] = state ? state.serviceAccountEmail : undefined; + resourceInputs["ttlDays"] = state ? state.ttlDays : undefined; + } else { + const args = argsOrState as ServiceAccountKeyArgs | undefined; + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.serviceAccountEmail === undefined) && !opts.urn) { + throw new Error("Missing required property 'serviceAccountEmail'"); + } + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["publicKey"] = args ? args.publicKey : undefined; + resourceInputs["rotateWhenChanged"] = args ? args.rotateWhenChanged : undefined; + resourceInputs["serviceAccountEmail"] = args ? args.serviceAccountEmail : undefined; + resourceInputs["ttlDays"] = args ? args.ttlDays : undefined; + resourceInputs["json"] = undefined /*out*/; + resourceInputs["keyId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["json"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(ServiceAccountKey.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering ServiceAccountKey resources. + */ +export interface ServiceAccountKeyState { + /** + * The raw JSON representation of the service account key json, available for direct use. + */ + json?: pulumi.Input; + /** + * The unique identifier for the key associated with the service account. + */ + keyId?: pulumi.Input; + /** + * The STACKIT project ID associated with the service account key. + */ + projectId?: pulumi.Input; + /** + * Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + */ + publicKey?: pulumi.Input; + /** + * A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The email address associated with the service account, used for account identification and communication. + */ + serviceAccountEmail?: pulumi.Input; + /** + * Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + */ + ttlDays?: pulumi.Input; +} + +/** + * The set of arguments for constructing a ServiceAccountKey resource. + */ +export interface ServiceAccountKeyArgs { + /** + * The STACKIT project ID associated with the service account key. + */ + projectId: pulumi.Input; + /** + * Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + */ + publicKey?: pulumi.Input; + /** + * A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + */ + rotateWhenChanged?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The email address associated with the service account, used for account identification and communication. + */ + serviceAccountEmail: pulumi.Input; + /** + * Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + */ + ttlDays?: pulumi.Input; +} diff --git a/sdk/nodejs/skeCluster.ts b/sdk/nodejs/skeCluster.ts new file mode 100644 index 0000000..6b36b5e --- /dev/null +++ b/sdk/nodejs/skeCluster.ts @@ -0,0 +1,268 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SKE Cluster Resource schema. Must have a `region` specified in the provider configuration. + * + * > When updating `nodePools` of a `stackit.SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied. + * + * ## Example Usage + */ +export class SkeCluster extends pulumi.CustomResource { + /** + * Get an existing SkeCluster 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?: SkeClusterState, opts?: pulumi.CustomResourceOptions): SkeCluster { + return new SkeCluster(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/skeCluster:SkeCluster'; + + /** + * Returns true if the given object is an instance of SkeCluster. 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 SkeCluster { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SkeCluster.__pulumiType; + } + + /** + * Flag to specify if privileged mode for containers is enabled or not. + * This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + * Deprecated as of Kubernetes 1.25 and later + */ + public readonly allowPrivilegedContainers!: pulumi.Output; + /** + * The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + */ + public /*out*/ readonly egressAddressRanges!: pulumi.Output; + /** + * A single extensions block as defined below. + */ + public readonly extensions!: pulumi.Output; + /** + * One or more hibernation block as defined below. + */ + public readonly hibernations!: pulumi.Output; + /** + * Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + * + * @deprecated Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + */ + public readonly kubernetesVersion!: pulumi.Output; + /** + * The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + */ + public readonly kubernetesVersionMin!: pulumi.Output; + /** + * Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + public /*out*/ readonly kubernetesVersionUsed!: pulumi.Output; + /** + * A single maintenance block as defined below. + */ + public readonly maintenance!: pulumi.Output; + /** + * The cluster name. + */ + public readonly name!: pulumi.Output; + /** + * Network block as defined below. + */ + public readonly network!: pulumi.Output; + /** + * One or more `nodePool` block as defined below. + */ + public readonly nodePools!: pulumi.Output; + /** + * STACKIT project ID to which the cluster is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + + /** + * Create a SkeCluster 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: SkeClusterArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SkeClusterArgs | SkeClusterState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SkeClusterState | undefined; + resourceInputs["allowPrivilegedContainers"] = state ? state.allowPrivilegedContainers : undefined; + resourceInputs["egressAddressRanges"] = state ? state.egressAddressRanges : undefined; + resourceInputs["extensions"] = state ? state.extensions : undefined; + resourceInputs["hibernations"] = state ? state.hibernations : undefined; + resourceInputs["kubernetesVersion"] = state ? state.kubernetesVersion : undefined; + resourceInputs["kubernetesVersionMin"] = state ? state.kubernetesVersionMin : undefined; + resourceInputs["kubernetesVersionUsed"] = state ? state.kubernetesVersionUsed : undefined; + resourceInputs["maintenance"] = state ? state.maintenance : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["network"] = state ? state.network : undefined; + resourceInputs["nodePools"] = state ? state.nodePools : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + } else { + const args = argsOrState as SkeClusterArgs | undefined; + if ((!args || args.nodePools === undefined) && !opts.urn) { + throw new Error("Missing required property 'nodePools'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["allowPrivilegedContainers"] = args ? args.allowPrivilegedContainers : undefined; + resourceInputs["extensions"] = args ? args.extensions : undefined; + resourceInputs["hibernations"] = args ? args.hibernations : undefined; + resourceInputs["kubernetesVersion"] = args ? args.kubernetesVersion : undefined; + resourceInputs["kubernetesVersionMin"] = args ? args.kubernetesVersionMin : undefined; + resourceInputs["maintenance"] = args ? args.maintenance : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["network"] = args ? args.network : undefined; + resourceInputs["nodePools"] = args ? args.nodePools : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["egressAddressRanges"] = undefined /*out*/; + resourceInputs["kubernetesVersionUsed"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(SkeCluster.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SkeCluster resources. + */ +export interface SkeClusterState { + /** + * Flag to specify if privileged mode for containers is enabled or not. + * This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + * Deprecated as of Kubernetes 1.25 and later + */ + allowPrivilegedContainers?: pulumi.Input; + /** + * The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + */ + egressAddressRanges?: pulumi.Input[]>; + /** + * A single extensions block as defined below. + */ + extensions?: pulumi.Input; + /** + * One or more hibernation block as defined below. + */ + hibernations?: pulumi.Input[]>; + /** + * Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + * + * @deprecated Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + */ + kubernetesVersion?: pulumi.Input; + /** + * The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + */ + kubernetesVersionMin?: pulumi.Input; + /** + * Full Kubernetes version used. For example, if 1.22 was set in `kubernetesVersionMin`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + kubernetesVersionUsed?: pulumi.Input; + /** + * A single maintenance block as defined below. + */ + maintenance?: pulumi.Input; + /** + * The cluster name. + */ + name?: pulumi.Input; + /** + * Network block as defined below. + */ + network?: pulumi.Input; + /** + * One or more `nodePool` block as defined below. + */ + nodePools?: pulumi.Input[]>; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SkeCluster resource. + */ +export interface SkeClusterArgs { + /** + * Flag to specify if privileged mode for containers is enabled or not. + * This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + * Deprecated as of Kubernetes 1.25 and later + */ + allowPrivilegedContainers?: pulumi.Input; + /** + * A single extensions block as defined below. + */ + extensions?: pulumi.Input; + /** + * One or more hibernation block as defined below. + */ + hibernations?: pulumi.Input[]>; + /** + * Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetesVersionMin instead` + * + * @deprecated Use `kubernetesVersionMin instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster. + */ + kubernetesVersion?: pulumi.Input; + /** + * The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetesVersionUsed` field. + */ + kubernetesVersionMin?: pulumi.Input; + /** + * A single maintenance block as defined below. + */ + maintenance?: pulumi.Input; + /** + * The cluster name. + */ + name?: pulumi.Input; + /** + * Network block as defined below. + */ + network?: pulumi.Input; + /** + * One or more `nodePool` block as defined below. + */ + nodePools: pulumi.Input[]>; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; +} diff --git a/sdk/nodejs/skeKubeconfig.ts b/sdk/nodejs/skeKubeconfig.ts new file mode 100644 index 0000000..a0ad11f --- /dev/null +++ b/sdk/nodejs/skeKubeconfig.ts @@ -0,0 +1,170 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SkeKubeconfig extends pulumi.CustomResource { + /** + * Get an existing SkeKubeconfig 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?: SkeKubeconfigState, opts?: pulumi.CustomResourceOptions): SkeKubeconfig { + return new SkeKubeconfig(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/skeKubeconfig:SkeKubeconfig'; + + /** + * Returns true if the given object is an instance of SkeKubeconfig. 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 SkeKubeconfig { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SkeKubeconfig.__pulumiType; + } + + /** + * Name of the SKE cluster. + */ + public readonly clusterName!: pulumi.Output; + /** + * Date-time when the kubeconfig was created + */ + public /*out*/ readonly creationTime!: pulumi.Output; + /** + * Expiration time of the kubeconfig, in seconds. Defaults to `3600` + */ + public readonly expiration!: pulumi.Output; + /** + * Timestamp when the kubeconfig expires + */ + public /*out*/ readonly expiresAt!: pulumi.Output; + /** + * Raw short-lived admin kubeconfig. + */ + public /*out*/ readonly kubeConfig!: pulumi.Output; + public /*out*/ readonly kubeConfigId!: pulumi.Output; + /** + * STACKIT project ID to which the cluster is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + */ + public readonly refresh!: pulumi.Output; + + /** + * Create a SkeKubeconfig 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: SkeKubeconfigArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SkeKubeconfigArgs | SkeKubeconfigState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SkeKubeconfigState | undefined; + resourceInputs["clusterName"] = state ? state.clusterName : undefined; + resourceInputs["creationTime"] = state ? state.creationTime : undefined; + resourceInputs["expiration"] = state ? state.expiration : undefined; + resourceInputs["expiresAt"] = state ? state.expiresAt : undefined; + resourceInputs["kubeConfig"] = state ? state.kubeConfig : undefined; + resourceInputs["kubeConfigId"] = state ? state.kubeConfigId : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["refresh"] = state ? state.refresh : undefined; + } else { + const args = argsOrState as SkeKubeconfigArgs | undefined; + if ((!args || args.clusterName === undefined) && !opts.urn) { + throw new Error("Missing required property 'clusterName'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["clusterName"] = args ? args.clusterName : undefined; + resourceInputs["expiration"] = args ? args.expiration : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["refresh"] = args ? args.refresh : undefined; + resourceInputs["creationTime"] = undefined /*out*/; + resourceInputs["expiresAt"] = undefined /*out*/; + resourceInputs["kubeConfig"] = undefined /*out*/; + resourceInputs["kubeConfigId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["kubeConfig"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(SkeKubeconfig.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SkeKubeconfig resources. + */ +export interface SkeKubeconfigState { + /** + * Name of the SKE cluster. + */ + clusterName?: pulumi.Input; + /** + * Date-time when the kubeconfig was created + */ + creationTime?: pulumi.Input; + /** + * Expiration time of the kubeconfig, in seconds. Defaults to `3600` + */ + expiration?: pulumi.Input; + /** + * Timestamp when the kubeconfig expires + */ + expiresAt?: pulumi.Input; + /** + * Raw short-lived admin kubeconfig. + */ + kubeConfig?: pulumi.Input; + kubeConfigId?: pulumi.Input; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId?: pulumi.Input; + /** + * If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + */ + refresh?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SkeKubeconfig resource. + */ +export interface SkeKubeconfigArgs { + /** + * Name of the SKE cluster. + */ + clusterName: pulumi.Input; + /** + * Expiration time of the kubeconfig, in seconds. Defaults to `3600` + */ + expiration?: pulumi.Input; + /** + * STACKIT project ID to which the cluster is associated. + */ + projectId: pulumi.Input; + /** + * If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + */ + refresh?: pulumi.Input; +} diff --git a/sdk/nodejs/sqlserverflexInstance.ts b/sdk/nodejs/sqlserverflexInstance.ts new file mode 100644 index 0000000..aeab512 --- /dev/null +++ b/sdk/nodejs/sqlserverflexInstance.ts @@ -0,0 +1,184 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SqlserverflexInstance extends pulumi.CustomResource { + /** + * Get an existing SqlserverflexInstance 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?: SqlserverflexInstanceState, opts?: pulumi.CustomResourceOptions): SqlserverflexInstance { + return new SqlserverflexInstance(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/sqlserverflexInstance:SqlserverflexInstance'; + + /** + * Returns true if the given object is an instance of SqlserverflexInstance. 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 SqlserverflexInstance { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SqlserverflexInstance.__pulumiType; + } + + /** + * The Access Control List (ACL) for the SQLServer Flex instance. + */ + public readonly acls!: pulumi.Output; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + */ + public readonly backupSchedule!: pulumi.Output; + public readonly flavor!: pulumi.Output; + /** + * ID of the SQLServer Flex instance. + */ + public /*out*/ readonly instanceId!: pulumi.Output; + /** + * Instance name. + */ + public readonly name!: pulumi.Output; + public readonly options!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The resource region. If not defined, the provider region is used. + */ + public readonly region!: pulumi.Output; + public /*out*/ readonly replicas!: pulumi.Output; + public readonly storage!: pulumi.Output; + public readonly version!: pulumi.Output; + + /** + * Create a SqlserverflexInstance 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: SqlserverflexInstanceArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SqlserverflexInstanceArgs | SqlserverflexInstanceState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SqlserverflexInstanceState | undefined; + resourceInputs["acls"] = state ? state.acls : undefined; + resourceInputs["backupSchedule"] = state ? state.backupSchedule : undefined; + resourceInputs["flavor"] = state ? state.flavor : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["options"] = state ? state.options : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["replicas"] = state ? state.replicas : undefined; + resourceInputs["storage"] = state ? state.storage : undefined; + resourceInputs["version"] = state ? state.version : undefined; + } else { + const args = argsOrState as SqlserverflexInstanceArgs | undefined; + if ((!args || args.flavor === undefined) && !opts.urn) { + throw new Error("Missing required property 'flavor'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["acls"] = args ? args.acls : undefined; + resourceInputs["backupSchedule"] = args ? args.backupSchedule : undefined; + resourceInputs["flavor"] = args ? args.flavor : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["options"] = args ? args.options : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["storage"] = args ? args.storage : undefined; + resourceInputs["version"] = args ? args.version : undefined; + resourceInputs["instanceId"] = undefined /*out*/; + resourceInputs["replicas"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(SqlserverflexInstance.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SqlserverflexInstance resources. + */ +export interface SqlserverflexInstanceState { + /** + * The Access Control List (ACL) for the SQLServer Flex instance. + */ + acls?: pulumi.Input[]>; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + */ + backupSchedule?: pulumi.Input; + flavor?: pulumi.Input; + /** + * ID of the SQLServer Flex instance. + */ + instanceId?: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + options?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + replicas?: pulumi.Input; + storage?: pulumi.Input; + version?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SqlserverflexInstance resource. + */ +export interface SqlserverflexInstanceArgs { + /** + * The Access Control List (ACL) for the SQLServer Flex instance. + */ + acls?: pulumi.Input[]>; + /** + * The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + */ + backupSchedule?: pulumi.Input; + flavor: pulumi.Input; + /** + * Instance name. + */ + name?: pulumi.Input; + options?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + /** + * The resource region. If not defined, the provider region is used. + */ + region?: pulumi.Input; + storage?: pulumi.Input; + version?: pulumi.Input; +} diff --git a/sdk/nodejs/sqlserverflexUser.ts b/sdk/nodejs/sqlserverflexUser.ts new file mode 100644 index 0000000..fdcd834 --- /dev/null +++ b/sdk/nodejs/sqlserverflexUser.ts @@ -0,0 +1,172 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class SqlserverflexUser extends pulumi.CustomResource { + /** + * Get an existing SqlserverflexUser 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?: SqlserverflexUserState, opts?: pulumi.CustomResourceOptions): SqlserverflexUser { + return new SqlserverflexUser(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/sqlserverflexUser:SqlserverflexUser'; + + /** + * Returns true if the given object is an instance of SqlserverflexUser. 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 SqlserverflexUser { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === SqlserverflexUser.__pulumiType; + } + + public /*out*/ readonly host!: pulumi.Output; + /** + * ID of the SQLServer Flex instance. + */ + public readonly instanceId!: pulumi.Output; + /** + * Password of the user account. + */ + public /*out*/ readonly password!: pulumi.Output; + public /*out*/ readonly port!: pulumi.Output; + /** + * STACKIT project ID to which the instance is associated. + */ + public readonly projectId!: pulumi.Output; + public readonly region!: pulumi.Output; + /** + * Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + */ + public readonly roles!: pulumi.Output; + /** + * User ID. + */ + public /*out*/ readonly userId!: pulumi.Output; + /** + * Username of the SQLServer Flex instance. + */ + public readonly username!: pulumi.Output; + + /** + * Create a SqlserverflexUser 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: SqlserverflexUserArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: SqlserverflexUserArgs | SqlserverflexUserState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as SqlserverflexUserState | undefined; + resourceInputs["host"] = state ? state.host : undefined; + resourceInputs["instanceId"] = state ? state.instanceId : undefined; + resourceInputs["password"] = state ? state.password : undefined; + resourceInputs["port"] = state ? state.port : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["region"] = state ? state.region : undefined; + resourceInputs["roles"] = state ? state.roles : undefined; + resourceInputs["userId"] = state ? state.userId : undefined; + resourceInputs["username"] = state ? state.username : undefined; + } else { + const args = argsOrState as SqlserverflexUserArgs | undefined; + if ((!args || args.instanceId === undefined) && !opts.urn) { + throw new Error("Missing required property 'instanceId'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + if ((!args || args.username === undefined) && !opts.urn) { + throw new Error("Missing required property 'username'"); + } + resourceInputs["instanceId"] = args ? args.instanceId : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["region"] = args ? args.region : undefined; + resourceInputs["roles"] = args ? args.roles : undefined; + resourceInputs["username"] = args ? args.username : undefined; + resourceInputs["host"] = undefined /*out*/; + resourceInputs["password"] = undefined /*out*/; + resourceInputs["port"] = undefined /*out*/; + resourceInputs["userId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + const secretOpts = { additionalSecretOutputs: ["password"] }; + opts = pulumi.mergeOptions(opts, secretOpts); + super(SqlserverflexUser.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering SqlserverflexUser resources. + */ +export interface SqlserverflexUserState { + host?: pulumi.Input; + /** + * ID of the SQLServer Flex instance. + */ + instanceId?: pulumi.Input; + /** + * Password of the user account. + */ + password?: pulumi.Input; + port?: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId?: pulumi.Input; + region?: pulumi.Input; + /** + * Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + */ + roles?: pulumi.Input[]>; + /** + * User ID. + */ + userId?: pulumi.Input; + /** + * Username of the SQLServer Flex instance. + */ + username?: pulumi.Input; +} + +/** + * The set of arguments for constructing a SqlserverflexUser resource. + */ +export interface SqlserverflexUserArgs { + /** + * ID of the SQLServer Flex instance. + */ + instanceId: pulumi.Input; + /** + * STACKIT project ID to which the instance is associated. + */ + projectId: pulumi.Input; + region?: pulumi.Input; + /** + * Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + */ + roles?: pulumi.Input[]>; + /** + * Username of the SQLServer Flex instance. + */ + username: pulumi.Input; +} diff --git a/sdk/nodejs/tsconfig.json b/sdk/nodejs/tsconfig.json new file mode 100644 index 0000000..a2fdeb4 --- /dev/null +++ b/sdk/nodejs/tsconfig.json @@ -0,0 +1,138 @@ +{ + "compilerOptions": { + "outDir": "bin", + "target": "es2016", + "module": "commonjs", + "moduleResolution": "node", + "declaration": true, + "sourceMap": true, + "stripInternal": true, + "experimentalDecorators": true, + "noFallthroughCasesInSwitch": true, + "forceConsistentCasingInFileNames": true, + "strict": true + }, + "files": [ + "affinityGroup.ts", + "authorizationOrganizationRoleAssignment.ts", + "authorizationProjectRoleAssignment.ts", + "cdnCustomDomain.ts", + "cdnDistribution.ts", + "config/index.ts", + "config/vars.ts", + "dnsRecordSet.ts", + "dnsZone.ts", + "getAffinityGroup.ts", + "getCdnCustomDomain.ts", + "getCdnDistribution.ts", + "getDnsRecordSet.ts", + "getDnsZone.ts", + "getGit.ts", + "getImage.ts", + "getKeyPair.ts", + "getLoadbalancer.ts", + "getLogmeCredential.ts", + "getLogmeInstance.ts", + "getMariadbCredential.ts", + "getMariadbInstance.ts", + "getMongodbflexInstance.ts", + "getMongodbflexUser.ts", + "getNetwork.ts", + "getNetworkArea.ts", + "getNetworkAreaRoute.ts", + "getNetworkInterface.ts", + "getObjectstorageBucket.ts", + "getObjectstorageCredential.ts", + "getObjectstorageCredentialsGroup.ts", + "getObservabilityAlertgroup.ts", + "getObservabilityInstance.ts", + "getObservabilityLogalertgroup.ts", + "getObservabilityScrapeconfig.ts", + "getOpensearchCredential.ts", + "getOpensearchInstance.ts", + "getPostgresflexDatabase.ts", + "getPostgresflexInstance.ts", + "getPostgresflexUser.ts", + "getPublicIp.ts", + "getPublicIpRanges.ts", + "getRabbitmqCredential.ts", + "getRabbitmqInstance.ts", + "getRedisCredential.ts", + "getRedisInstance.ts", + "getResourcemanagerProject.ts", + "getSecretsmanagerInstance.ts", + "getSecretsmanagerUser.ts", + "getSecurityGroup.ts", + "getSecurityGroupRule.ts", + "getServer.ts", + "getServerBackupSchedule.ts", + "getServerBackupSchedules.ts", + "getServerUpdateSchedule.ts", + "getServerUpdateSchedules.ts", + "getServiceAccount.ts", + "getSkeCluster.ts", + "getSqlserverflexInstance.ts", + "getSqlserverflexUser.ts", + "getVolume.ts", + "git.ts", + "image.ts", + "index.ts", + "keyPair.ts", + "loadbalancer.ts", + "loadbalancerObservabilityCredential.ts", + "logmeCredential.ts", + "logmeInstance.ts", + "mariadbCredential.ts", + "mariadbInstance.ts", + "modelservingToken.ts", + "mongodbflexInstance.ts", + "mongodbflexUser.ts", + "network.ts", + "networkArea.ts", + "networkAreaRoute.ts", + "networkInterface.ts", + "objectstorageBucket.ts", + "objectstorageCredential.ts", + "objectstorageCredentialsGroup.ts", + "observabilityAlertgroup.ts", + "observabilityCredential.ts", + "observabilityInstance.ts", + "observabilityLogalertgroup.ts", + "observabilityScrapeconfig.ts", + "opensearchCredential.ts", + "opensearchInstance.ts", + "postgresflexDatabase.ts", + "postgresflexInstance.ts", + "postgresflexUser.ts", + "provider.ts", + "publicIp.ts", + "publicIpAssociate.ts", + "rabbitmqCredential.ts", + "rabbitmqInstance.ts", + "redisCredential.ts", + "redisInstance.ts", + "resourcemanagerProject.ts", + "secretsmanagerInstance.ts", + "secretsmanagerUser.ts", + "securityGroup.ts", + "securityGroupRule.ts", + "server.ts", + "serverBackupSchedule.ts", + "serverNetworkInterfaceAttach.ts", + "serverServiceAccountAttach.ts", + "serverUpdateSchedule.ts", + "serverVolumeAttach.ts", + "serviceAccount.ts", + "serviceAccountAccessToken.ts", + "serviceAccountKey.ts", + "skeCluster.ts", + "skeKubeconfig.ts", + "sqlserverflexInstance.ts", + "sqlserverflexUser.ts", + "types/index.ts", + "types/input.ts", + "types/output.ts", + "utilities.ts", + "volume.ts" + ] +} diff --git a/sdk/nodejs/types/index.ts b/sdk/nodejs/types/index.ts new file mode 100644 index 0000000..f0db274 --- /dev/null +++ b/sdk/nodejs/types/index.ts @@ -0,0 +1,13 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as utilities from "../utilities"; + +// Export sub-modules: +import * as input from "./input"; +import * as output from "./output"; + +export { + input, + output, +}; diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts new file mode 100644 index 0000000..99aa96b --- /dev/null +++ b/sdk/nodejs/types/input.ts @@ -0,0 +1,1158 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +export interface CdnDistributionConfig { + /** + * The configured backend for the distribution + */ + backend: pulumi.Input; + /** + * The configured regions where content will be hosted + */ + regions: pulumi.Input[]>; +} + +export interface CdnDistributionConfigBackend { + /** + * The configured origin request headers for the backend + */ + originRequestHeaders?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The configured backend type for the distribution + */ + originUrl: pulumi.Input; + /** + * The configured backend type. Supported values are: `http`. + */ + type: pulumi.Input; +} + +export interface CdnDistributionDomain { + /** + * List of domain errors + */ + errors?: pulumi.Input[]>; + /** + * The name of the domain + */ + name?: pulumi.Input; + /** + * The status of the domain + */ + status?: pulumi.Input; + /** + * The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + */ + type?: pulumi.Input; +} + +export interface ImageChecksum { + /** + * Algorithm for the checksum of the image data. + */ + algorithm?: pulumi.Input; + /** + * Hexdigest of the checksum of the image data. + */ + digest?: pulumi.Input; +} + +export interface ImageConfig { + /** + * Enables the BIOS bootmenu. + */ + bootMenu?: pulumi.Input; + /** + * Sets CDROM bus controller type. + */ + cdromBus?: pulumi.Input; + /** + * Sets Disk bus controller type. + */ + diskBus?: pulumi.Input; + /** + * Sets virtual network interface model. + */ + nicModel?: pulumi.Input; + /** + * Enables operating system specific optimizations. + */ + operatingSystem?: pulumi.Input; + /** + * Operating system distribution. + */ + operatingSystemDistro?: pulumi.Input; + /** + * Version of the operating system. + */ + operatingSystemVersion?: pulumi.Input; + /** + * Sets the device bus when the image is used as a rescue image. + */ + rescueBus?: pulumi.Input; + /** + * Sets the device when the image is used as a rescue image. + */ + rescueDevice?: pulumi.Input; + /** + * Enables Secure Boot. + */ + secureBoot?: pulumi.Input; + /** + * Enables UEFI boot. + */ + uefi?: pulumi.Input; + /** + * Sets Graphic device model. + */ + videoModel?: pulumi.Input; + /** + * Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + */ + virtioScsi?: pulumi.Input; +} + +export interface LoadbalancerListener { + displayName?: pulumi.Input; + /** + * Port number where we listen for traffic. + */ + port: pulumi.Input; + /** + * Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + */ + protocol: pulumi.Input; + /** + * A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + */ + serverNameIndicators?: pulumi.Input[]>; + /** + * Reference target pool by target pool name. + */ + targetPool: pulumi.Input; +} + +export interface LoadbalancerListenerServerNameIndicator { + /** + * A domain name to match in order to pass TLS traffic to the target pool in the current listener + */ + name?: pulumi.Input; +} + +export interface LoadbalancerNetwork { + /** + * Openstack network ID. + */ + networkId: pulumi.Input; + /** + * The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + */ + role: pulumi.Input; +} + +export interface LoadbalancerOptions { + /** + * Load Balancer is accessible only from an IP address in this range. + */ + acls?: pulumi.Input[]>; + /** + * We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + */ + observability?: pulumi.Input; + /** + * If true, Load Balancer is accessible only via a private network IP address. + */ + privateNetworkOnly?: pulumi.Input; +} + +export interface LoadbalancerOptionsObservability { + /** + * Observability logs configuration. Not changeable after creation. + */ + logs?: pulumi.Input; + /** + * Observability metrics configuration. Not changeable after creation. + */ + metrics?: pulumi.Input; +} + +export interface LoadbalancerOptionsObservabilityLogs { + /** + * Credentials reference for logs. Not changeable after creation. + */ + credentialsRef?: pulumi.Input; + /** + * Credentials reference for logs. Not changeable after creation. + */ + pushUrl?: pulumi.Input; +} + +export interface LoadbalancerOptionsObservabilityMetrics { + /** + * Credentials reference for metrics. Not changeable after creation. + */ + credentialsRef?: pulumi.Input; + /** + * Credentials reference for metrics. Not changeable after creation. + */ + pushUrl?: pulumi.Input; +} + +export interface LoadbalancerTargetPool { + activeHealthCheck?: pulumi.Input; + /** + * Target pool name. + */ + name: pulumi.Input; + /** + * Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + */ + sessionPersistence?: pulumi.Input; + /** + * Identical port number where each target listens for traffic. + */ + targetPort: pulumi.Input; + /** + * List of all targets which will be used in the pool. Limited to 1000. + */ + targets: pulumi.Input[]>; +} + +export interface LoadbalancerTargetPoolActiveHealthCheck { + /** + * Healthy threshold of the health checking. + */ + healthyThreshold?: pulumi.Input; + /** + * Interval duration of health checking in seconds. + */ + interval?: pulumi.Input; + /** + * Interval duration threshold of the health checking in seconds. + */ + intervalJitter?: pulumi.Input; + /** + * Active health checking timeout duration in seconds. + */ + timeout?: pulumi.Input; + /** + * Unhealthy threshold of the health checking. + */ + unhealthyThreshold?: pulumi.Input; +} + +export interface LoadbalancerTargetPoolSessionPersistence { + /** + * If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + */ + useSourceIpAddress?: pulumi.Input; +} + +export interface LoadbalancerTargetPoolTarget { + /** + * Target display name + */ + displayName: pulumi.Input; + /** + * Target IP + */ + ip: pulumi.Input; +} + +export interface LogmeInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring?: pulumi.Input; + fluentdTcp?: pulumi.Input; + fluentdTls?: pulumi.Input; + fluentdTlsCiphers?: pulumi.Input; + fluentdTlsMaxVersion?: pulumi.Input; + fluentdTlsMinVersion?: pulumi.Input; + fluentdTlsVersion?: pulumi.Input; + fluentdUdp?: pulumi.Input; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite?: pulumi.Input; + /** + * Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + */ + ismDeletionAfter?: pulumi.Input; + ismJitter?: pulumi.Input; + /** + * Jitter of the execution time. + */ + ismJobInterval?: pulumi.Input; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace?: pulumi.Input; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace?: pulumi.Input; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold?: pulumi.Input; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency?: pulumi.Input; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix?: pulumi.Input; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId?: pulumi.Input; + opensearchTlsCiphers?: pulumi.Input[]>; + opensearchTlsProtocols?: pulumi.Input[]>; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl?: pulumi.Input; + /** + * List of syslog servers to send logs to. + */ + syslogs?: pulumi.Input[]>; +} + +export interface MariadbInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring?: pulumi.Input; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite?: pulumi.Input; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold?: pulumi.Input; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency?: pulumi.Input; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix?: pulumi.Input; + /** + * The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + */ + monitoringInstanceId?: pulumi.Input; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl?: pulumi.Input; + /** + * List of syslog servers to send logs to. + */ + syslogs?: pulumi.Input[]>; +} + +export interface MongodbflexInstanceFlavor { + cpu: pulumi.Input; + description?: pulumi.Input; + id?: pulumi.Input; + ram: pulumi.Input; +} + +export interface MongodbflexInstanceOptions { + /** + * The number of days that daily backups will be retained. + */ + dailySnapshotRetentionDays?: pulumi.Input; + /** + * The number of months that monthly backups will be retained. + */ + monthlySnapshotRetentionMonths?: pulumi.Input; + /** + * The number of hours back in time the point-in-time recovery feature will be able to recover. + */ + pointInTimeWindowHours: pulumi.Input; + /** + * The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + */ + snapshotRetentionDays?: pulumi.Input; + /** + * Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + */ + type: pulumi.Input; + /** + * The number of weeks that weekly backups will be retained. + */ + weeklySnapshotRetentionWeeks?: pulumi.Input; +} + +export interface MongodbflexInstanceStorage { + class: pulumi.Input; + size: pulumi.Input; +} + +export interface NetworkAreaNetworkRange { + networkRangeId?: pulumi.Input; + /** + * Classless Inter-Domain Routing (CIDR). + */ + prefix: pulumi.Input; +} + +export interface ObservabilityAlertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: pulumi.Input; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: pulumi.Input; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for?: pulumi.Input; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; +} + +export interface ObservabilityInstanceAlertConfig { + /** + * Global configuration for the alerts. + */ + global?: pulumi.Input; + /** + * List of alert receivers. + */ + receivers: pulumi.Input[]>; + /** + * Route configuration for the alerts. + */ + route: pulumi.Input; +} + +export interface ObservabilityInstanceAlertConfigGlobal { + /** + * The API key for OpsGenie. + */ + opsgenieApiKey?: pulumi.Input; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + opsgenieApiUrl?: pulumi.Input; + /** + * The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + */ + resolveTimeout?: pulumi.Input; + /** + * SMTP authentication information. Must be a valid email address + */ + smtpAuthIdentity?: pulumi.Input; + /** + * SMTP Auth using LOGIN and PLAIN. + */ + smtpAuthPassword?: pulumi.Input; + /** + * SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + */ + smtpAuthUsername?: pulumi.Input; + /** + * The default SMTP From header field. Must be a valid email address + */ + smtpFrom?: pulumi.Input; + /** + * The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + */ + smtpSmartHost?: pulumi.Input; +} + +export interface ObservabilityInstanceAlertConfigReceiver { + /** + * List of email configurations. + */ + emailConfigs?: pulumi.Input[]>; + /** + * Name of the receiver. + */ + name: pulumi.Input; + /** + * List of OpsGenie configurations. + */ + opsgenieConfigs?: pulumi.Input[]>; + /** + * List of Webhooks configurations. + */ + webhooksConfigs?: pulumi.Input[]>; +} + +export interface ObservabilityInstanceAlertConfigReceiverEmailConfig { + /** + * SMTP authentication information. Must be a valid email address + */ + authIdentity?: pulumi.Input; + /** + * SMTP authentication password. + */ + authPassword?: pulumi.Input; + /** + * SMTP authentication username. + */ + authUsername?: pulumi.Input; + /** + * The sender email address. Must be a valid email address + */ + from?: pulumi.Input; + /** + * The SMTP host through which emails are sent. + */ + smartHost?: pulumi.Input; + /** + * The email address to send notifications to. Must be a valid email address + */ + to?: pulumi.Input; +} + +export interface ObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + /** + * The API key for OpsGenie. + */ + apiKey?: pulumi.Input; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + apiUrl?: pulumi.Input; + /** + * Comma separated list of tags attached to the notifications. + */ + tags?: pulumi.Input; +} + +export interface ObservabilityInstanceAlertConfigReceiverWebhooksConfig { + /** + * Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + */ + msTeams?: pulumi.Input; + /** + * The endpoint to send HTTP POST requests to. Must be a valid URL + */ + url?: pulumi.Input; +} + +export interface ObservabilityInstanceAlertConfigRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies?: pulumi.Input[]>; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval?: pulumi.Input; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + */ + groupWait?: pulumi.Input; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the receiver to route the alerts to. + */ + receiver: pulumi.Input; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval?: pulumi.Input; + /** + * List of child routes. + */ + routes?: pulumi.Input[]>; +} + +export interface ObservabilityInstanceAlertConfigRouteRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies?: pulumi.Input[]>; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval?: pulumi.Input; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + */ + groupWait?: pulumi.Input; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the receiver to route the alerts to. + */ + receiver: pulumi.Input; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval?: pulumi.Input; +} + +export interface ObservabilityLogalertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: pulumi.Input; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: pulumi.Input; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for?: pulumi.Input; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; +} + +export interface ObservabilityScrapeconfigBasicAuth { + /** + * Specifies basic auth password. + */ + password: pulumi.Input; + /** + * Specifies basic auth username. + */ + username: pulumi.Input; +} + +export interface ObservabilityScrapeconfigSaml2 { + /** + * Specifies if URL parameters are enabled. Defaults to `true` + */ + enableUrlParameters?: pulumi.Input; +} + +export interface ObservabilityScrapeconfigTarget { + /** + * Specifies labels. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * Specifies target URLs. + */ + urls: pulumi.Input[]>; +} + +export interface OpensearchInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring?: pulumi.Input; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite?: pulumi.Input; + /** + * The garbage collector to use for OpenSearch. + */ + javaGarbageCollector?: pulumi.Input; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace?: pulumi.Input; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace?: pulumi.Input; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold?: pulumi.Input; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency?: pulumi.Input; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix?: pulumi.Input; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId?: pulumi.Input; + /** + * List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + */ + plugins?: pulumi.Input[]>; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl?: pulumi.Input; + /** + * List of syslog servers to send logs to. + */ + syslogs?: pulumi.Input[]>; + /** + * List of TLS ciphers to use. + */ + tlsCiphers?: pulumi.Input[]>; + /** + * The TLS protocol to use. + */ + tlsProtocols?: pulumi.Input; +} + +export interface PostgresflexInstanceFlavor { + cpu: pulumi.Input; + description?: pulumi.Input; + id?: pulumi.Input; + ram: pulumi.Input; +} + +export interface PostgresflexInstanceStorage { + class: pulumi.Input; + size: pulumi.Input; +} + +export interface RabbitmqInstanceParameters { + /** + * The timeout in milliseconds for the consumer. + */ + consumerTimeout?: pulumi.Input; + /** + * Enable monitoring. + */ + enableMonitoring?: pulumi.Input; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite?: pulumi.Input; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold?: pulumi.Input; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency?: pulumi.Input; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix?: pulumi.Input; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId?: pulumi.Input; + /** + * List of plugins to install. Must be a supported plugin name. + */ + plugins?: pulumi.Input[]>; + /** + * List of roles to assign to the instance. + */ + roles?: pulumi.Input[]>; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl?: pulumi.Input; + /** + * List of syslog servers to send logs to. + */ + syslogs?: pulumi.Input[]>; + /** + * List of TLS ciphers to use. + */ + tlsCiphers?: pulumi.Input[]>; + /** + * TLS protocol to use. + */ + tlsProtocols?: pulumi.Input; +} + +export interface RedisInstanceParameters { + /** + * The number of milliseconds after which the instance is considered down. + */ + downAfterMilliseconds?: pulumi.Input; + /** + * Enable monitoring. + */ + enableMonitoring?: pulumi.Input; + /** + * The failover timeout in milliseconds. + */ + failoverTimeout?: pulumi.Input; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite?: pulumi.Input; + /** + * The lazy eviction enablement (yes or no). + */ + lazyfreeLazyEviction?: pulumi.Input; + /** + * The lazy expire enablement (yes or no). + */ + lazyfreeLazyExpire?: pulumi.Input; + /** + * The Lua time limit. + */ + luaTimeLimit?: pulumi.Input; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold?: pulumi.Input; + /** + * The maximum number of clients. + */ + maxclients?: pulumi.Input; + /** + * The policy to handle the maximum memory (volatile-lru, noeviction, etc). + */ + maxmemoryPolicy?: pulumi.Input; + /** + * The maximum memory samples. + */ + maxmemorySamples?: pulumi.Input; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency?: pulumi.Input; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix?: pulumi.Input; + /** + * The minimum replicas maximum lag. + */ + minReplicasMaxLag?: pulumi.Input; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId?: pulumi.Input; + /** + * The notify keyspace events. + */ + notifyKeyspaceEvents?: pulumi.Input; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl?: pulumi.Input; + /** + * The snapshot configuration. + */ + snapshot?: pulumi.Input; + /** + * List of syslog servers to send logs to. + */ + syslogs?: pulumi.Input[]>; + /** + * List of TLS ciphers to use. + */ + tlsCiphers?: pulumi.Input[]>; + /** + * TLS cipher suites to use. + */ + tlsCiphersuites?: pulumi.Input; + /** + * TLS protocol to use. + */ + tlsProtocols?: pulumi.Input; +} + +export interface SecurityGroupRuleIcmpParameters { + /** + * ICMP code. Can be set if the protocol is ICMP. + */ + code: pulumi.Input; + /** + * ICMP type. Can be set if the protocol is ICMP. + */ + type: pulumi.Input; +} + +export interface SecurityGroupRulePortRange { + /** + * The maximum port number. Should be greater or equal to the minimum. + */ + max: pulumi.Input; + /** + * The minimum port number. Should be less or equal to the maximum. + */ + min: pulumi.Input; +} + +export interface SecurityGroupRuleProtocol { + /** + * The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + */ + name?: pulumi.Input; + /** + * The protocol number which the rule should match. Either `name` or `number` must be provided. + */ + number?: pulumi.Input; +} + +export interface ServerBackupScheduleBackupProperties { + name: pulumi.Input; + retentionPeriod: pulumi.Input; + volumeIds?: pulumi.Input[]>; +} + +export interface ServerBootVolume { + /** + * Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. + */ + deleteOnTermination?: pulumi.Input; + /** + * The ID of the boot volume + */ + id?: pulumi.Input; + /** + * The performance class of the server. + */ + performanceClass?: pulumi.Input; + /** + * The size of the boot volume in GB. Must be provided when `sourceType` is `image`. + */ + size?: pulumi.Input; + /** + * The ID of the source, either image ID or volume ID + */ + sourceId: pulumi.Input; + /** + * The type of the source. Supported values are: `volume`, `image`. + */ + sourceType: pulumi.Input; +} + +export interface SkeClusterExtensions { + /** + * Cluster access control configuration. + */ + acl?: pulumi.Input; + /** + * A single argus block as defined below. + */ + argus?: pulumi.Input; + /** + * DNS extension configuration + */ + dns?: pulumi.Input; +} + +export interface SkeClusterExtensionsAcl { + /** + * Specify a list of CIDRs to whitelist. + */ + allowedCidrs: pulumi.Input[]>; + /** + * Is ACL enabled? + */ + enabled: pulumi.Input; +} + +export interface SkeClusterExtensionsArgus { + /** + * Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + */ + argusInstanceId?: pulumi.Input; + /** + * Flag to enable/disable Argus extensions. + */ + enabled: pulumi.Input; +} + +export interface SkeClusterExtensionsDns { + /** + * Flag to enable/disable DNS extensions + */ + enabled: pulumi.Input; + /** + * Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + */ + zones?: pulumi.Input[]>; +} + +export interface SkeClusterHibernation { + /** + * End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + */ + end: pulumi.Input; + /** + * Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + */ + start: pulumi.Input; + /** + * Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + */ + timezone?: pulumi.Input; +} + +export interface SkeClusterMaintenance { + /** + * Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + enableKubernetesVersionUpdates?: pulumi.Input; + /** + * Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + enableMachineImageVersionUpdates?: pulumi.Input; + /** + * Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + */ + end: pulumi.Input; + /** + * Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + */ + start: pulumi.Input; +} + +export interface SkeClusterNetwork { + /** + * ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + */ + id?: pulumi.Input; +} + +export interface SkeClusterNodePool { + /** + * Allow system components to run on this node pool. + */ + allowSystemComponents?: pulumi.Input; + /** + * Specify a list of availability zones. E.g. `eu01-m` + */ + availabilityZones: pulumi.Input[]>; + /** + * Specifies the container runtime. Defaults to `containerd` + */ + cri?: pulumi.Input; + /** + * Labels to add to each node. + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The machine type. + */ + machineType: pulumi.Input; + /** + * Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + */ + maxSurge?: pulumi.Input; + /** + * Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + */ + maxUnavailable?: pulumi.Input; + /** + * Maximum number of nodes in the pool. + */ + maximum: pulumi.Input; + /** + * Minimum number of nodes in the pool. + */ + minimum: pulumi.Input; + /** + * Specifies the name of the node pool. + */ + name: pulumi.Input; + /** + * The name of the OS image. Defaults to `flatcar`. + */ + osName?: pulumi.Input; + /** + * This field is deprecated, use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. + * + * @deprecated Use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates. + */ + osVersion?: pulumi.Input; + /** + * The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + */ + osVersionMin?: pulumi.Input; + /** + * Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + osVersionUsed?: pulumi.Input; + /** + * Specifies a taint list as defined below. + */ + taints?: pulumi.Input[]>; + /** + * The volume size in GB. Defaults to `20` + */ + volumeSize?: pulumi.Input; + /** + * Specifies the volume type. Defaults to `storagePremiumPerf1`. + */ + volumeType?: pulumi.Input; +} + +export interface SkeClusterNodePoolTaint { + /** + * The taint effect. E.g `PreferNoSchedule`. + */ + effect: pulumi.Input; + /** + * Taint key to be applied to a node. + */ + key: pulumi.Input; + /** + * Taint value corresponding to the taint key. + */ + value?: pulumi.Input; +} + +export interface SqlserverflexInstanceFlavor { + cpu: pulumi.Input; + description?: pulumi.Input; + id?: pulumi.Input; + ram: pulumi.Input; +} + +export interface SqlserverflexInstanceOptions { + edition?: pulumi.Input; + retentionDays?: pulumi.Input; +} + +export interface SqlserverflexInstanceStorage { + class?: pulumi.Input; + size?: pulumi.Input; +} + +export interface VolumeSource { + /** + * The ID of the source, e.g. image ID + */ + id: pulumi.Input; + /** + * The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + */ + type: pulumi.Input; +} diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts new file mode 100644 index 0000000..7946cb1 --- /dev/null +++ b/sdk/nodejs/types/output.ts @@ -0,0 +1,2340 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +export interface CdnDistributionConfig { + /** + * The configured backend for the distribution + */ + backend: outputs.CdnDistributionConfigBackend; + /** + * The configured regions where content will be hosted + */ + regions: string[]; +} + +export interface CdnDistributionConfigBackend { + /** + * The configured origin request headers for the backend + */ + originRequestHeaders?: {[key: string]: string}; + /** + * The configured backend type for the distribution + */ + originUrl: string; + /** + * The configured backend type. Supported values are: `http`. + */ + type: string; +} + +export interface CdnDistributionDomain { + /** + * List of domain errors + */ + errors: string[]; + /** + * The name of the domain + */ + name: string; + /** + * The status of the domain + */ + status: string; + /** + * The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + */ + type: string; +} + +export interface GetCdnDistributionConfig { + /** + * The configured backend for the distribution + */ + backend: outputs.GetCdnDistributionConfigBackend; + /** + * The configured regions where content will be hosted + */ + regions: string[]; +} + +export interface GetCdnDistributionConfigBackend { + /** + * The configured origin request headers for the backend + */ + originRequestHeaders: {[key: string]: string}; + /** + * The configured backend type for the distribution + */ + originUrl: string; + /** + * The configured backend type. Supported values are: `http`. + */ + type: string; +} + +export interface GetCdnDistributionDomain { + /** + * List of domain errors + */ + errors: string[]; + /** + * The name of the domain + */ + name: string; + /** + * The status of the domain + */ + status: string; + /** + * The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + */ + type: string; +} + +export interface GetImageChecksum { + /** + * Algorithm for the checksum of the image data. + */ + algorithm: string; + /** + * Hexdigest of the checksum of the image data. + */ + digest: string; +} + +export interface GetImageConfig { + /** + * Enables the BIOS bootmenu. + */ + bootMenu: boolean; + /** + * Sets CDROM bus controller type. + */ + cdromBus: string; + /** + * Sets Disk bus controller type. + */ + diskBus: string; + /** + * Sets virtual network interface model. + */ + nicModel: string; + /** + * Enables operating system specific optimizations. + */ + operatingSystem: string; + /** + * Operating system distribution. + */ + operatingSystemDistro: string; + /** + * Version of the operating system. + */ + operatingSystemVersion: string; + /** + * Sets the device bus when the image is used as a rescue image. + */ + rescueBus: string; + /** + * Sets the device when the image is used as a rescue image. + */ + rescueDevice: string; + /** + * Enables Secure Boot. + */ + secureBoot: boolean; + /** + * Enables UEFI boot. + */ + uefi: boolean; + /** + * Sets Graphic device model. + */ + videoModel: string; + /** + * Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + */ + virtioScsi: boolean; +} + +export interface GetLoadbalancerListener { + displayName: string; + /** + * Port number where we listen for traffic. + */ + port: number; + /** + * Protocol is the highest network protocol we understand to load balance. + */ + protocol: string; + /** + * A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + */ + serverNameIndicators?: outputs.GetLoadbalancerListenerServerNameIndicator[]; + /** + * Reference target pool by target pool name. + */ + targetPool: string; +} + +export interface GetLoadbalancerListenerServerNameIndicator { + /** + * A domain name to match in order to pass TLS traffic to the target pool in the current listener + */ + name?: string; +} + +export interface GetLoadbalancerNetwork { + /** + * Openstack network ID. + */ + networkId: string; + /** + * The role defines how the load balancer is using the network. + */ + role: string; +} + +export interface GetLoadbalancerOptions { + /** + * Load Balancer is accessible only from an IP address in this range. + */ + acls: string[]; + /** + * We offer Load Balancer metrics observability via ARGUS or external solutions. + */ + observability: outputs.GetLoadbalancerOptionsObservability; + /** + * If true, Load Balancer is accessible only via a private network IP address. + */ + privateNetworkOnly: boolean; +} + +export interface GetLoadbalancerOptionsObservability { + /** + * Observability logs configuration. + */ + logs: outputs.GetLoadbalancerOptionsObservabilityLogs; + /** + * Observability metrics configuration. + */ + metrics: outputs.GetLoadbalancerOptionsObservabilityMetrics; +} + +export interface GetLoadbalancerOptionsObservabilityLogs { + /** + * Credentials reference for logs. + */ + credentialsRef: string; + /** + * Credentials reference for logs. + */ + pushUrl: string; +} + +export interface GetLoadbalancerOptionsObservabilityMetrics { + /** + * Credentials reference for metrics. + */ + credentialsRef: string; + /** + * Credentials reference for metrics. + */ + pushUrl: string; +} + +export interface GetLoadbalancerTargetPool { + activeHealthCheck: outputs.GetLoadbalancerTargetPoolActiveHealthCheck; + /** + * Target pool name. + */ + name: string; + /** + * Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + */ + sessionPersistence?: outputs.GetLoadbalancerTargetPoolSessionPersistence; + /** + * Identical port number where each target listens for traffic. + */ + targetPort: number; + /** + * List of all targets which will be used in the pool. Limited to 1000. + */ + targets: outputs.GetLoadbalancerTargetPoolTarget[]; +} + +export interface GetLoadbalancerTargetPoolActiveHealthCheck { + /** + * Healthy threshold of the health checking. + */ + healthyThreshold: number; + /** + * Interval duration of health checking in seconds. + */ + interval: string; + /** + * Interval duration threshold of the health checking in seconds. + */ + intervalJitter: string; + /** + * Active health checking timeout duration in seconds. + */ + timeout: string; + /** + * Unhealthy threshold of the health checking. + */ + unhealthyThreshold: number; +} + +export interface GetLoadbalancerTargetPoolSessionPersistence { + /** + * If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + */ + useSourceIpAddress?: boolean; +} + +export interface GetLoadbalancerTargetPoolTarget { + /** + * Target display name + */ + displayName: string; + /** + * Target IP + */ + ip: string; +} + +export interface GetLogmeInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + fluentdTcp: number; + fluentdTls: number; + fluentdTlsCiphers: string; + fluentdTlsMaxVersion: string; + fluentdTlsMinVersion: string; + fluentdTlsVersion: string; + fluentdUdp: number; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite: string; + /** + * Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + */ + ismDeletionAfter: string; + ismJitter: number; + /** + * Jitter of the execution time. + */ + ismJobInterval: number; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace: number; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + opensearchTlsCiphers: string[]; + opensearchTlsProtocols: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; +} + +export interface GetMariadbInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + graphite: string; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; +} + +export interface GetMongodbflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface GetMongodbflexInstanceOptions { + /** + * The number of days that daily backups will be retained. + */ + dailySnapshotRetentionDays: number; + /** + * The number of months that monthly backups will be retained. + */ + monthlySnapshotRetentionMonths: number; + /** + * The number of hours back in time the point-in-time recovery feature will be able to recover. + */ + pointInTimeWindowHours: number; + /** + * The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + */ + snapshotRetentionDays: number; + /** + * Type of the MongoDB Flex instance. + */ + type: string; + /** + * The number of weeks that weekly backups will be retained. + */ + weeklySnapshotRetentionWeeks: number; +} + +export interface GetMongodbflexInstanceStorage { + class: string; + size: number; +} + +export interface GetNetworkAreaNetworkRange { + networkRangeId: string; + prefix: string; +} + +export interface GetObservabilityAlertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: string; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations: {[key: string]: string}; + /** + * The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: string; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for: string; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels: {[key: string]: string}; +} + +export interface GetObservabilityInstanceAlertConfig { + /** + * Global configuration for the alerts. + */ + global: outputs.GetObservabilityInstanceAlertConfigGlobal; + /** + * List of alert receivers. + */ + receivers: outputs.GetObservabilityInstanceAlertConfigReceiver[]; + /** + * The route for the alert. + */ + route: outputs.GetObservabilityInstanceAlertConfigRoute; +} + +export interface GetObservabilityInstanceAlertConfigGlobal { + /** + * The API key for OpsGenie. + */ + opsgenieApiKey: string; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + opsgenieApiUrl: string; + /** + * The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + */ + resolveTimeout: string; + /** + * SMTP authentication information. Must be a valid email address + */ + smtpAuthIdentity: string; + /** + * SMTP Auth using LOGIN and PLAIN. + */ + smtpAuthPassword: string; + /** + * SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + */ + smtpAuthUsername: string; + /** + * The default SMTP From header field. Must be a valid email address + */ + smtpFrom: string; + /** + * The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + */ + smtpSmartHost: string; +} + +export interface GetObservabilityInstanceAlertConfigReceiver { + /** + * List of email configurations. + */ + emailConfigs: outputs.GetObservabilityInstanceAlertConfigReceiverEmailConfig[]; + /** + * Name of the receiver. + */ + name: string; + /** + * List of OpsGenie configurations. + */ + opsgenieConfigs: outputs.GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig[]; + /** + * List of Webhooks configurations. + */ + webhooksConfigs: outputs.GetObservabilityInstanceAlertConfigReceiverWebhooksConfig[]; +} + +export interface GetObservabilityInstanceAlertConfigReceiverEmailConfig { + /** + * SMTP authentication information. Must be a valid email address + */ + authIdentity: string; + /** + * SMTP authentication password. + */ + authPassword: string; + /** + * SMTP authentication username. + */ + authUsername: string; + /** + * The sender email address. Must be a valid email address + */ + from: string; + /** + * The SMTP host through which emails are sent. + */ + smartHost: string; + /** + * The email address to send notifications to. Must be a valid email address + */ + to: string; +} + +export interface GetObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + /** + * The API key for OpsGenie. + */ + apiKey: string; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + apiUrl: string; + /** + * Comma separated list of tags attached to the notifications. + */ + tags: string; +} + +export interface GetObservabilityInstanceAlertConfigReceiverWebhooksConfig { + /** + * Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + */ + msTeams: boolean; + /** + * The endpoint to send HTTP POST requests to. Must be a valid URL + */ + url: string; +} + +export interface GetObservabilityInstanceAlertConfigRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies: string[]; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval: string; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + */ + groupWait: string; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match: {[key: string]: string}; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex: {[key: string]: string}; + /** + * The name of the receiver to route the alerts to. + */ + receiver: string; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval: string; + /** + * List of child routes. + */ + routes: outputs.GetObservabilityInstanceAlertConfigRouteRoute[]; +} + +export interface GetObservabilityInstanceAlertConfigRouteRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies: string[]; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval: string; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + */ + groupWait: string; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match: {[key: string]: string}; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex: {[key: string]: string}; + /** + * The name of the receiver to route the alerts to. + */ + receiver: string; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval: string; +} + +export interface GetObservabilityLogalertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: string; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations: {[key: string]: string}; + /** + * The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: string; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for: string; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels: {[key: string]: string}; +} + +export interface GetObservabilityScrapeconfigBasicAuth { + /** + * Specifies basic auth password. + */ + password: string; + /** + * Specifies basic auth username. + */ + username: string; +} + +export interface GetObservabilityScrapeconfigSaml2 { + /** + * Specifies if URL parameters are enabled + */ + enableUrlParameters: boolean; +} + +export interface GetObservabilityScrapeconfigTarget { + /** + * Specifies labels. + */ + labels: {[key: string]: string}; + /** + * Specifies target URLs. + */ + urls: string[]; +} + +export interface GetOpensearchInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite: string; + /** + * The garbage collector to use for OpenSearch. + */ + javaGarbageCollector: string; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace: number; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + */ + plugins: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * The TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface GetPostgresflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface GetPostgresflexInstanceStorage { + class: string; + size: number; +} + +export interface GetPublicIpRangesPublicIpRange { + /** + * Classless Inter-Domain Routing (CIDR) + */ + cidr: string; +} + +export interface GetRabbitmqInstanceParameters { + /** + * The timeout in milliseconds for the consumer. + */ + consumerTimeout: number; + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite: string; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * List of plugins to install. Must be a supported plugin name. + */ + plugins: string[]; + /** + * List of roles to assign to the instance. + */ + roles: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface GetRedisInstanceParameters { + /** + * The number of milliseconds after which the instance is considered down. + */ + downAfterMilliseconds: number; + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * The failover timeout in milliseconds. + */ + failoverTimeout: number; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite: string; + /** + * The lazy eviction enablement (yes or no). + */ + lazyfreeLazyEviction: string; + /** + * The lazy expire enablement (yes or no). + */ + lazyfreeLazyExpire: string; + /** + * The Lua time limit. + */ + luaTimeLimit: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The maximum number of clients. + */ + maxclients: number; + /** + * The policy to handle the maximum memory (volatile-lru, noeviction, etc). + */ + maxmemoryPolicy: string; + /** + * The maximum memory samples. + */ + maxmemorySamples: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The minimum replicas maximum lag. + */ + minReplicasMaxLag: number; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * The notify keyspace events. + */ + notifyKeyspaceEvents: string; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * The snapshot configuration. + */ + snapshot: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * TLS cipher suites to use. + */ + tlsCiphersuites: string; + /** + * TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface GetSecurityGroupRuleIcmpParameters { + /** + * ICMP code. Can be set if the protocol is ICMP. + */ + code: number; + /** + * ICMP type. Can be set if the protocol is ICMP. + */ + type: number; +} + +export interface GetSecurityGroupRulePortRange { + /** + * The maximum port number. Should be greater or equal to the minimum. + */ + max: number; + /** + * The minimum port number. Should be less or equal to the minimum. + */ + min: number; +} + +export interface GetSecurityGroupRuleProtocol { + /** + * The protocol name which the rule should match. + */ + name: string; + /** + * The protocol number which the rule should match. + */ + number: number; +} + +export interface GetServerBackupScheduleBackupProperties { + name: string; + retentionPeriod: number; + volumeIds: string[]; +} + +export interface GetServerBackupSchedulesItem { + /** + * Backup schedule details for the backups. + */ + backupProperties: outputs.GetServerBackupSchedulesItemBackupProperties; + backupScheduleId: number; + /** + * Is the backup schedule enabled or disabled. + */ + enabled: boolean; + /** + * The backup schedule name. + */ + name: string; + /** + * Backup schedule described in `rrule` (recurrence rule) format. + */ + rrule: string; +} + +export interface GetServerBackupSchedulesItemBackupProperties { + name: string; + retentionPeriod: number; + volumeIds: string[]; +} + +export interface GetServerBootVolume { + /** + * Delete the volume during the termination of the server. + */ + deleteOnTermination: boolean; + /** + * The ID of the boot volume + */ + id: string; +} + +export interface GetServerUpdateSchedulesItem { + /** + * Is the update schedule enabled or disabled. + */ + enabled: boolean; + /** + * Maintenance window [1..24]. + */ + maintenanceWindow: number; + /** + * The update schedule name. + */ + name: string; + /** + * Update schedule described in `rrule` (recurrence rule) format. + */ + rrule: string; + updateScheduleId: number; +} + +export interface GetSkeClusterExtensions { + /** + * Cluster access control configuration + */ + acl: outputs.GetSkeClusterExtensionsAcl; + /** + * A single argus block as defined below + */ + argus: outputs.GetSkeClusterExtensionsArgus; + /** + * DNS extension configuration + */ + dns: outputs.GetSkeClusterExtensionsDns; +} + +export interface GetSkeClusterExtensionsAcl { + /** + * Specify a list of CIDRs to whitelist + */ + allowedCidrs: string[]; + /** + * Is ACL enabled? + */ + enabled: boolean; +} + +export interface GetSkeClusterExtensionsArgus { + /** + * Instance ID of argus + */ + argusInstanceId: string; + /** + * Flag to enable/disable argus extensions. + */ + enabled: boolean; +} + +export interface GetSkeClusterExtensionsDns { + /** + * Flag to enable/disable DNS extensions + */ + enabled: boolean; + /** + * Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + */ + zones: string[]; +} + +export interface GetSkeClusterHibernation { + /** + * End time of hibernation, in crontab syntax. + */ + end: string; + /** + * Start time of cluster hibernation in crontab syntax. + */ + start: string; + /** + * Timezone name corresponding to a file in the IANA Time Zone database. + */ + timezone: string; +} + +export interface GetSkeClusterMaintenance { + /** + * Flag to enable/disable auto-updates of the Kubernetes version. + */ + enableKubernetesVersionUpdates: boolean; + /** + * Flag to enable/disable auto-updates of the OS image version. + */ + enableMachineImageVersionUpdates: boolean; + /** + * Date time for maintenance window end. + */ + end: string; + /** + * Date time for maintenance window start. + */ + start: string; +} + +export interface GetSkeClusterNetwork { + /** + * ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + */ + id: string; +} + +export interface GetSkeClusterNodePool { + /** + * Allow system components to run on this node pool. + */ + allowSystemComponents: boolean; + /** + * Specify a list of availability zones. + */ + availabilityZones: string[]; + /** + * Specifies the container runtime. + */ + cri: string; + /** + * Labels to add to each node. + */ + labels: {[key: string]: string}; + /** + * The machine type. + */ + machineType: string; + /** + * The maximum number of nodes upgraded simultaneously. + */ + maxSurge: number; + /** + * The maximum number of nodes unavailable during upgraded. + */ + maxUnavailable: number; + /** + * Maximum number of nodes in the pool. + */ + maximum: number; + /** + * Minimum number of nodes in the pool. + */ + minimum: number; + /** + * Specifies the name of the node pool. + */ + name: string; + /** + * The name of the OS image. + */ + osName: string; + /** + * The OS image version. + */ + osVersion: string; + /** + * The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + */ + osVersionMin: string; + /** + * Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + osVersionUsed: string; + /** + * Specifies a taint list as defined below. + */ + taints: outputs.GetSkeClusterNodePoolTaint[]; + /** + * The volume size in GB. + */ + volumeSize: number; + /** + * Specifies the volume type. + */ + volumeType: string; +} + +export interface GetSkeClusterNodePoolTaint { + /** + * The taint effect. + */ + effect: string; + /** + * Taint key to be applied to a node. + */ + key: string; + /** + * Taint value corresponding to the taint key. + */ + value: string; +} + +export interface GetSqlserverflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface GetSqlserverflexInstanceOptions { + edition: string; + retentionDays: number; +} + +export interface GetSqlserverflexInstanceStorage { + class: string; + size: number; +} + +export interface GetVolumeSource { + /** + * The ID of the source, e.g. image ID + */ + id: string; + /** + * The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + */ + type: string; +} + +export interface ImageChecksum { + /** + * Algorithm for the checksum of the image data. + */ + algorithm: string; + /** + * Hexdigest of the checksum of the image data. + */ + digest: string; +} + +export interface ImageConfig { + /** + * Enables the BIOS bootmenu. + */ + bootMenu: boolean; + /** + * Sets CDROM bus controller type. + */ + cdromBus: string; + /** + * Sets Disk bus controller type. + */ + diskBus: string; + /** + * Sets virtual network interface model. + */ + nicModel: string; + /** + * Enables operating system specific optimizations. + */ + operatingSystem: string; + /** + * Operating system distribution. + */ + operatingSystemDistro: string; + /** + * Version of the operating system. + */ + operatingSystemVersion: string; + /** + * Sets the device bus when the image is used as a rescue image. + */ + rescueBus: string; + /** + * Sets the device when the image is used as a rescue image. + */ + rescueDevice: string; + /** + * Enables Secure Boot. + */ + secureBoot: boolean; + /** + * Enables UEFI boot. + */ + uefi: boolean; + /** + * Sets Graphic device model. + */ + videoModel: string; + /** + * Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + */ + virtioScsi: boolean; +} + +export interface LoadbalancerListener { + displayName: string; + /** + * Port number where we listen for traffic. + */ + port: number; + /** + * Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + */ + protocol: string; + /** + * A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + */ + serverNameIndicators?: outputs.LoadbalancerListenerServerNameIndicator[]; + /** + * Reference target pool by target pool name. + */ + targetPool: string; +} + +export interface LoadbalancerListenerServerNameIndicator { + /** + * A domain name to match in order to pass TLS traffic to the target pool in the current listener + */ + name?: string; +} + +export interface LoadbalancerNetwork { + /** + * Openstack network ID. + */ + networkId: string; + /** + * The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + */ + role: string; +} + +export interface LoadbalancerOptions { + /** + * Load Balancer is accessible only from an IP address in this range. + */ + acls: string[]; + /** + * We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + */ + observability: outputs.LoadbalancerOptionsObservability; + /** + * If true, Load Balancer is accessible only via a private network IP address. + */ + privateNetworkOnly: boolean; +} + +export interface LoadbalancerOptionsObservability { + /** + * Observability logs configuration. Not changeable after creation. + */ + logs: outputs.LoadbalancerOptionsObservabilityLogs; + /** + * Observability metrics configuration. Not changeable after creation. + */ + metrics: outputs.LoadbalancerOptionsObservabilityMetrics; +} + +export interface LoadbalancerOptionsObservabilityLogs { + /** + * Credentials reference for logs. Not changeable after creation. + */ + credentialsRef: string; + /** + * Credentials reference for logs. Not changeable after creation. + */ + pushUrl: string; +} + +export interface LoadbalancerOptionsObservabilityMetrics { + /** + * Credentials reference for metrics. Not changeable after creation. + */ + credentialsRef: string; + /** + * Credentials reference for metrics. Not changeable after creation. + */ + pushUrl: string; +} + +export interface LoadbalancerTargetPool { + activeHealthCheck: outputs.LoadbalancerTargetPoolActiveHealthCheck; + /** + * Target pool name. + */ + name: string; + /** + * Here you can setup various session persistence options, so far only "`useSourceIpAddress`" is supported. + */ + sessionPersistence?: outputs.LoadbalancerTargetPoolSessionPersistence; + /** + * Identical port number where each target listens for traffic. + */ + targetPort: number; + /** + * List of all targets which will be used in the pool. Limited to 1000. + */ + targets: outputs.LoadbalancerTargetPoolTarget[]; +} + +export interface LoadbalancerTargetPoolActiveHealthCheck { + /** + * Healthy threshold of the health checking. + */ + healthyThreshold: number; + /** + * Interval duration of health checking in seconds. + */ + interval: string; + /** + * Interval duration threshold of the health checking in seconds. + */ + intervalJitter: string; + /** + * Active health checking timeout duration in seconds. + */ + timeout: string; + /** + * Unhealthy threshold of the health checking. + */ + unhealthyThreshold: number; +} + +export interface LoadbalancerTargetPoolSessionPersistence { + /** + * If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + */ + useSourceIpAddress?: boolean; +} + +export interface LoadbalancerTargetPoolTarget { + /** + * Target display name + */ + displayName: string; + /** + * Target IP + */ + ip: string; +} + +export interface LogmeInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + fluentdTcp: number; + fluentdTls: number; + fluentdTlsCiphers: string; + fluentdTlsMaxVersion: string; + fluentdTlsMinVersion: string; + fluentdTlsVersion: string; + fluentdUdp: number; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite: string; + /** + * Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + */ + ismDeletionAfter: string; + ismJitter: number; + /** + * Jitter of the execution time. + */ + ismJobInterval: number; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace: number; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + opensearchTlsCiphers: string[]; + opensearchTlsProtocols: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; +} + +export interface MariadbInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite: string; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + */ + monitoringInstanceId: string; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; +} + +export interface MongodbflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface MongodbflexInstanceOptions { + /** + * The number of days that daily backups will be retained. + */ + dailySnapshotRetentionDays: number; + /** + * The number of months that monthly backups will be retained. + */ + monthlySnapshotRetentionMonths: number; + /** + * The number of hours back in time the point-in-time recovery feature will be able to recover. + */ + pointInTimeWindowHours: number; + /** + * The number of days that continuous backups (controlled via the `backupSchedule`) will be retained. + */ + snapshotRetentionDays: number; + /** + * Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + */ + type: string; + /** + * The number of weeks that weekly backups will be retained. + */ + weeklySnapshotRetentionWeeks: number; +} + +export interface MongodbflexInstanceStorage { + class: string; + size: number; +} + +export interface NetworkAreaNetworkRange { + networkRangeId: string; + /** + * Classless Inter-Domain Routing (CIDR). + */ + prefix: string; +} + +export interface ObservabilityAlertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: string; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations?: {[key: string]: string}; + /** + * The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: string; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for?: string; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels?: {[key: string]: string}; +} + +export interface ObservabilityInstanceAlertConfig { + /** + * Global configuration for the alerts. + */ + global: outputs.ObservabilityInstanceAlertConfigGlobal; + /** + * List of alert receivers. + */ + receivers: outputs.ObservabilityInstanceAlertConfigReceiver[]; + /** + * Route configuration for the alerts. + */ + route: outputs.ObservabilityInstanceAlertConfigRoute; +} + +export interface ObservabilityInstanceAlertConfigGlobal { + /** + * The API key for OpsGenie. + */ + opsgenieApiKey?: string; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + opsgenieApiUrl?: string; + /** + * The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + */ + resolveTimeout: string; + /** + * SMTP authentication information. Must be a valid email address + */ + smtpAuthIdentity?: string; + /** + * SMTP Auth using LOGIN and PLAIN. + */ + smtpAuthPassword?: string; + /** + * SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + */ + smtpAuthUsername?: string; + /** + * The default SMTP From header field. Must be a valid email address + */ + smtpFrom: string; + /** + * The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + */ + smtpSmartHost?: string; +} + +export interface ObservabilityInstanceAlertConfigReceiver { + /** + * List of email configurations. + */ + emailConfigs?: outputs.ObservabilityInstanceAlertConfigReceiverEmailConfig[]; + /** + * Name of the receiver. + */ + name: string; + /** + * List of OpsGenie configurations. + */ + opsgenieConfigs?: outputs.ObservabilityInstanceAlertConfigReceiverOpsgenieConfig[]; + /** + * List of Webhooks configurations. + */ + webhooksConfigs?: outputs.ObservabilityInstanceAlertConfigReceiverWebhooksConfig[]; +} + +export interface ObservabilityInstanceAlertConfigReceiverEmailConfig { + /** + * SMTP authentication information. Must be a valid email address + */ + authIdentity?: string; + /** + * SMTP authentication password. + */ + authPassword?: string; + /** + * SMTP authentication username. + */ + authUsername?: string; + /** + * The sender email address. Must be a valid email address + */ + from?: string; + /** + * The SMTP host through which emails are sent. + */ + smartHost?: string; + /** + * The email address to send notifications to. Must be a valid email address + */ + to?: string; +} + +export interface ObservabilityInstanceAlertConfigReceiverOpsgenieConfig { + /** + * The API key for OpsGenie. + */ + apiKey?: string; + /** + * The host to send OpsGenie API requests to. Must be a valid URL + */ + apiUrl?: string; + /** + * Comma separated list of tags attached to the notifications. + */ + tags?: string; +} + +export interface ObservabilityInstanceAlertConfigReceiverWebhooksConfig { + /** + * Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + */ + msTeams?: boolean; + /** + * The endpoint to send HTTP POST requests to. Must be a valid URL + */ + url?: string; +} + +export interface ObservabilityInstanceAlertConfigRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies?: string[]; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval: string; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + */ + groupWait: string; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match?: {[key: string]: string}; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex?: {[key: string]: string}; + /** + * The name of the receiver to route the alerts to. + */ + receiver: string; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval: string; + /** + * List of child routes. + */ + routes?: outputs.ObservabilityInstanceAlertConfigRouteRoute[]; +} + +export interface ObservabilityInstanceAlertConfigRouteRoute { + /** + * The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + */ + groupBies?: string[]; + /** + * How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + */ + groupInterval: string; + /** + * How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + */ + groupWait: string; + /** + * A set of equality matchers an alert has to fulfill to match the node. + */ + match?: {[key: string]: string}; + /** + * A set of regex-matchers an alert has to fulfill to match the node. + */ + matchRegex?: {[key: string]: string}; + /** + * The name of the receiver to route the alerts to. + */ + receiver: string; + /** + * How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + */ + repeatInterval: string; +} + +export interface ObservabilityLogalertgroupRule { + /** + * The name of the alert rule. Is the identifier and must be unique in the group. + */ + alert: string; + /** + * A map of key:value. Annotations to add or overwrite for each alert + */ + annotations?: {[key: string]: string}; + /** + * The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + */ + expression: string; + /** + * Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + */ + for?: string; + /** + * A map of key:value. Labels to add or overwrite for each alert + */ + labels?: {[key: string]: string}; +} + +export interface ObservabilityScrapeconfigBasicAuth { + /** + * Specifies basic auth password. + */ + password: string; + /** + * Specifies basic auth username. + */ + username: string; +} + +export interface ObservabilityScrapeconfigSaml2 { + /** + * Specifies if URL parameters are enabled. Defaults to `true` + */ + enableUrlParameters: boolean; +} + +export interface ObservabilityScrapeconfigTarget { + /** + * Specifies labels. + */ + labels?: {[key: string]: string}; + /** + * Specifies target URLs. + */ + urls: string[]; +} + +export interface OpensearchInstanceParameters { + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + */ + graphite: string; + /** + * The garbage collector to use for OpenSearch. + */ + javaGarbageCollector: string; + /** + * The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + */ + javaHeapspace: number; + /** + * The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + */ + javaMaxmetaspace: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted (in seconds). + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + */ + plugins: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * The TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface PostgresflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface PostgresflexInstanceStorage { + class: string; + size: number; +} + +export interface RabbitmqInstanceParameters { + /** + * The timeout in milliseconds for the consumer. + */ + consumerTimeout: number; + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite: string; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * List of plugins to install. Must be a supported plugin name. + */ + plugins: string[]; + /** + * List of roles to assign to the instance. + */ + roles: string[]; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface RedisInstanceParameters { + /** + * The number of milliseconds after which the instance is considered down. + */ + downAfterMilliseconds: number; + /** + * Enable monitoring. + */ + enableMonitoring: boolean; + /** + * The failover timeout in milliseconds. + */ + failoverTimeout: number; + /** + * Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + */ + graphite: string; + /** + * The lazy eviction enablement (yes or no). + */ + lazyfreeLazyEviction: string; + /** + * The lazy expire enablement (yes or no). + */ + lazyfreeLazyExpire: string; + /** + * The Lua time limit. + */ + luaTimeLimit: number; + /** + * The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + */ + maxDiskThreshold: number; + /** + * The maximum number of clients. + */ + maxclients: number; + /** + * The policy to handle the maximum memory (volatile-lru, noeviction, etc). + */ + maxmemoryPolicy: string; + /** + * The maximum memory samples. + */ + maxmemorySamples: number; + /** + * The frequency in seconds at which metrics are emitted. + */ + metricsFrequency: number; + /** + * The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + */ + metricsPrefix: string; + /** + * The minimum replicas maximum lag. + */ + minReplicasMaxLag: number; + /** + * The ID of the STACKIT monitoring instance. + */ + monitoringInstanceId: string; + /** + * The notify keyspace events. + */ + notifyKeyspaceEvents: string; + /** + * Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + */ + sgwAcl: string; + /** + * The snapshot configuration. + */ + snapshot: string; + /** + * List of syslog servers to send logs to. + */ + syslogs: string[]; + /** + * List of TLS ciphers to use. + */ + tlsCiphers: string[]; + /** + * TLS cipher suites to use. + */ + tlsCiphersuites: string; + /** + * TLS protocol to use. + */ + tlsProtocols: string; +} + +export interface SecurityGroupRuleIcmpParameters { + /** + * ICMP code. Can be set if the protocol is ICMP. + */ + code: number; + /** + * ICMP type. Can be set if the protocol is ICMP. + */ + type: number; +} + +export interface SecurityGroupRulePortRange { + /** + * The maximum port number. Should be greater or equal to the minimum. + */ + max: number; + /** + * The minimum port number. Should be less or equal to the maximum. + */ + min: number; +} + +export interface SecurityGroupRuleProtocol { + /** + * The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + */ + name: string; + /** + * The protocol number which the rule should match. Either `name` or `number` must be provided. + */ + number: number; +} + +export interface ServerBackupScheduleBackupProperties { + name: string; + retentionPeriod: number; + volumeIds?: string[]; +} + +export interface ServerBootVolume { + /** + * Delete the volume during the termination of the server. Only allowed when `sourceType` is `image`. + */ + deleteOnTermination: boolean; + /** + * The ID of the boot volume + */ + id: string; + /** + * The performance class of the server. + */ + performanceClass?: string; + /** + * The size of the boot volume in GB. Must be provided when `sourceType` is `image`. + */ + size?: number; + /** + * The ID of the source, either image ID or volume ID + */ + sourceId: string; + /** + * The type of the source. Supported values are: `volume`, `image`. + */ + sourceType: string; +} + +export interface SkeClusterExtensions { + /** + * Cluster access control configuration. + */ + acl?: outputs.SkeClusterExtensionsAcl; + /** + * A single argus block as defined below. + */ + argus?: outputs.SkeClusterExtensionsArgus; + /** + * DNS extension configuration + */ + dns?: outputs.SkeClusterExtensionsDns; +} + +export interface SkeClusterExtensionsAcl { + /** + * Specify a list of CIDRs to whitelist. + */ + allowedCidrs: string[]; + /** + * Is ACL enabled? + */ + enabled: boolean; +} + +export interface SkeClusterExtensionsArgus { + /** + * Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + */ + argusInstanceId?: string; + /** + * Flag to enable/disable Argus extensions. + */ + enabled: boolean; +} + +export interface SkeClusterExtensionsDns { + /** + * Flag to enable/disable DNS extensions + */ + enabled: boolean; + /** + * Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + */ + zones: string[]; +} + +export interface SkeClusterHibernation { + /** + * End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + */ + end: string; + /** + * Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + */ + start: string; + /** + * Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + */ + timezone: string; +} + +export interface SkeClusterMaintenance { + /** + * Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + enableKubernetesVersionUpdates: boolean; + /** + * Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + enableMachineImageVersionUpdates: boolean; + /** + * Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + */ + end: string; + /** + * Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + */ + start: string; +} + +export interface SkeClusterNetwork { + /** + * ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + */ + id?: string; +} + +export interface SkeClusterNodePool { + /** + * Allow system components to run on this node pool. + */ + allowSystemComponents: boolean; + /** + * Specify a list of availability zones. E.g. `eu01-m` + */ + availabilityZones: string[]; + /** + * Specifies the container runtime. Defaults to `containerd` + */ + cri: string; + /** + * Labels to add to each node. + */ + labels: {[key: string]: string}; + /** + * The machine type. + */ + machineType: string; + /** + * Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + */ + maxSurge: number; + /** + * Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `maxSurge` and `maxUnavailable` fields cannot both be unset at the same time. + */ + maxUnavailable: number; + /** + * Maximum number of nodes in the pool. + */ + maximum: number; + /** + * Minimum number of nodes in the pool. + */ + minimum: number; + /** + * Specifies the name of the node pool. + */ + name: string; + /** + * The name of the OS image. Defaults to `flatcar`. + */ + osName: string; + /** + * This field is deprecated, use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. + * + * @deprecated Use `osVersionMin` to configure the version and `osVersionUsed` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates. + */ + osVersion?: string; + /** + * The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `osVersionUsed` field. + */ + osVersionMin?: string; + /** + * Full OS image version used. For example, if 3815.2 was set in `osVersionMin`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + */ + osVersionUsed: string; + /** + * Specifies a taint list as defined below. + */ + taints?: outputs.SkeClusterNodePoolTaint[]; + /** + * The volume size in GB. Defaults to `20` + */ + volumeSize: number; + /** + * Specifies the volume type. Defaults to `storagePremiumPerf1`. + */ + volumeType: string; +} + +export interface SkeClusterNodePoolTaint { + /** + * The taint effect. E.g `PreferNoSchedule`. + */ + effect: string; + /** + * Taint key to be applied to a node. + */ + key: string; + /** + * Taint value corresponding to the taint key. + */ + value: string; +} + +export interface SqlserverflexInstanceFlavor { + cpu: number; + description: string; + id: string; + ram: number; +} + +export interface SqlserverflexInstanceOptions { + edition: string; + retentionDays: number; +} + +export interface SqlserverflexInstanceStorage { + class: string; + size: number; +} + +export interface VolumeSource { + /** + * The ID of the source, e.g. image ID + */ + id: string; + /** + * The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + */ + type: string; +} + diff --git a/sdk/nodejs/utilities.ts b/sdk/nodejs/utilities.ts new file mode 100644 index 0000000..aeb83e2 --- /dev/null +++ b/sdk/nodejs/utilities.ts @@ -0,0 +1,96 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + + +import * as runtime from "@pulumi/pulumi/runtime"; +import * as pulumi from "@pulumi/pulumi"; + +export function getEnv(...vars: string[]): string | undefined { + for (const v of vars) { + const value = process.env[v]; + if (value) { + return value; + } + } + return undefined; +} + +export function getEnvBoolean(...vars: string[]): boolean | undefined { + const s = getEnv(...vars); + if (s !== undefined) { + // NOTE: these values are taken from https://golang.org/src/strconv/atob.go?s=351:391#L1, which is what + // Terraform uses internally when parsing boolean values. + if (["1", "t", "T", "true", "TRUE", "True"].find(v => v === s) !== undefined) { + return true; + } + if (["0", "f", "F", "false", "FALSE", "False"].find(v => v === s) !== undefined) { + return false; + } + } + return undefined; +} + +export function getEnvNumber(...vars: string[]): number | undefined { + const s = getEnv(...vars); + if (s !== undefined) { + const f = parseFloat(s); + if (!isNaN(f)) { + return f; + } + } + return undefined; +} + +export function getVersion(): string { + let version = require('./package.json').version; + // Node allows for the version to be prefixed by a "v", while semver doesn't. + // If there is a v, strip it off. + if (version.indexOf('v') === 0) { + version = version.slice(1); + } + return version; +} + +/** @internal */ +export function resourceOptsDefaults(): any { + return { version: getVersion(), pluginDownloadURL: "github://api.github.com/stackitcloud/pulumi-stackit" }; +} + +/** @internal */ +export function lazyLoad(exports: any, props: string[], loadModule: any) { + for (let property of props) { + Object.defineProperty(exports, property, { + enumerable: true, + get: function() { + return loadModule()[property]; + }, + }); + } +} + +/** @internal */ +export async function callAsync( + tok: string, + props: pulumi.Inputs, + res?: pulumi.Resource, + opts?: {property?: string}, +): Promise { + const o: any = runtime.call(tok, props, res); + const value = await o.promise(true /*withUnknowns*/); + const isKnown = await o.isKnown; + const isSecret = await o.isSecret; + const problem: string|undefined = + !isKnown ? "an unknown value" + : isSecret ? "a secret value" + : undefined; + // Ingoring o.resources silently. They are typically non-empty, r.f() calls include r as a dependency. + if (problem) { + throw new Error(`Plain resource method "${tok}" incorrectly returned ${problem}. ` + + "This is an error in the provider, please report this to the provider developer."); + } + // Extract a single property if requested. + if (opts && opts.property) { + return value[opts.property]; + } + return value; +} diff --git a/sdk/nodejs/volume.ts b/sdk/nodejs/volume.ts new file mode 100644 index 0000000..7210c33 --- /dev/null +++ b/sdk/nodejs/volume.ts @@ -0,0 +1,212 @@ +// *** WARNING: this file was generated by pulumi-language-nodejs. *** +// *** 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"; + +/** + * Volume resource schema. Must have a `region` specified in the provider configuration. + * + * ## Example Usage + */ +export class Volume extends pulumi.CustomResource { + /** + * Get an existing Volume 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?: VolumeState, opts?: pulumi.CustomResourceOptions): Volume { + return new Volume(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'stackit:index/volume:Volume'; + + /** + * Returns true if the given object is an instance of Volume. 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 Volume { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === Volume.__pulumiType; + } + + /** + * The availability zone of the volume. + */ + public readonly availabilityZone!: pulumi.Output; + /** + * The description of the volume. + */ + public readonly description!: pulumi.Output; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + public readonly labels!: pulumi.Output<{[key: string]: string} | undefined>; + /** + * The name of the volume. + */ + public readonly name!: pulumi.Output; + /** + * The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + */ + public readonly performanceClass!: pulumi.Output; + /** + * STACKIT project ID to which the volume is associated. + */ + public readonly projectId!: pulumi.Output; + /** + * The server ID of the server to which the volume is attached to. + */ + public /*out*/ readonly serverId!: pulumi.Output; + /** + * The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + */ + public readonly size!: pulumi.Output; + /** + * The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + */ + public readonly source!: pulumi.Output; + /** + * The volume ID. + */ + public /*out*/ readonly volumeId!: pulumi.Output; + + /** + * Create a Volume 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: VolumeArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: VolumeArgs | VolumeState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as VolumeState | undefined; + resourceInputs["availabilityZone"] = state ? state.availabilityZone : undefined; + resourceInputs["description"] = state ? state.description : undefined; + resourceInputs["labels"] = state ? state.labels : undefined; + resourceInputs["name"] = state ? state.name : undefined; + resourceInputs["performanceClass"] = state ? state.performanceClass : undefined; + resourceInputs["projectId"] = state ? state.projectId : undefined; + resourceInputs["serverId"] = state ? state.serverId : undefined; + resourceInputs["size"] = state ? state.size : undefined; + resourceInputs["source"] = state ? state.source : undefined; + resourceInputs["volumeId"] = state ? state.volumeId : undefined; + } else { + const args = argsOrState as VolumeArgs | undefined; + if ((!args || args.availabilityZone === undefined) && !opts.urn) { + throw new Error("Missing required property 'availabilityZone'"); + } + if ((!args || args.projectId === undefined) && !opts.urn) { + throw new Error("Missing required property 'projectId'"); + } + resourceInputs["availabilityZone"] = args ? args.availabilityZone : undefined; + resourceInputs["description"] = args ? args.description : undefined; + resourceInputs["labels"] = args ? args.labels : undefined; + resourceInputs["name"] = args ? args.name : undefined; + resourceInputs["performanceClass"] = args ? args.performanceClass : undefined; + resourceInputs["projectId"] = args ? args.projectId : undefined; + resourceInputs["size"] = args ? args.size : undefined; + resourceInputs["source"] = args ? args.source : undefined; + resourceInputs["serverId"] = undefined /*out*/; + resourceInputs["volumeId"] = undefined /*out*/; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(Volume.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering Volume resources. + */ +export interface VolumeState { + /** + * The availability zone of the volume. + */ + availabilityZone?: pulumi.Input; + /** + * The description of the volume. + */ + description?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the volume. + */ + name?: pulumi.Input; + /** + * The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + */ + performanceClass?: pulumi.Input; + /** + * STACKIT project ID to which the volume is associated. + */ + projectId?: pulumi.Input; + /** + * The server ID of the server to which the volume is attached to. + */ + serverId?: pulumi.Input; + /** + * The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + */ + size?: pulumi.Input; + /** + * The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + */ + source?: pulumi.Input; + /** + * The volume ID. + */ + volumeId?: pulumi.Input; +} + +/** + * The set of arguments for constructing a Volume resource. + */ +export interface VolumeArgs { + /** + * The availability zone of the volume. + */ + availabilityZone: pulumi.Input; + /** + * The description of the volume. + */ + description?: pulumi.Input; + /** + * Labels are key-value string pairs which can be attached to a resource container + */ + labels?: pulumi.Input<{[key: string]: pulumi.Input}>; + /** + * The name of the volume. + */ + name?: pulumi.Input; + /** + * The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + */ + performanceClass?: pulumi.Input; + /** + * STACKIT project ID to which the volume is associated. + */ + projectId: pulumi.Input; + /** + * The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + */ + size?: pulumi.Input; + /** + * The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + */ + source?: pulumi.Input; +} diff --git a/sdk/python/Pulumi.yaml b/sdk/python/Pulumi.yaml new file mode 100644 index 0000000..e69de29 diff --git a/sdk/python/pulumi_stackit/README.md b/sdk/python/pulumi_stackit/README.md new file mode 100644 index 0000000..c081626 --- /dev/null +++ b/sdk/python/pulumi_stackit/README.md @@ -0,0 +1,4 @@ +> This provider is a derived work of the [Terraform Provider](https://github.com/stackitcloud/terraform-provider-stackit) +> distributed under [MPL 2.0](https://www.mozilla.org/en-US/MPL/2.0/). If you encounter a bug or missing feature, +> first check the [`pulumi-stackit` repo](https://github.com/stackitcloud/pulumi-stackit/issues); however, if that doesn't turn up anything, +> please consult the source [`terraform-provider-stackit` repo](https://github.com/stackitcloud/terraform-provider-stackit/issues). \ No newline at end of file diff --git a/sdk/python/pulumi_stackit/__init__.py b/sdk/python/pulumi_stackit/__init__.py new file mode 100644 index 0000000..7d105f5 --- /dev/null +++ b/sdk/python/pulumi_stackit/__init__.py @@ -0,0 +1,636 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +from . import _utilities +import typing +# Export this package's modules as members: +from .affinity_group import * +from .authorization_organization_role_assignment import * +from .authorization_project_role_assignment import * +from .cdn_custom_domain import * +from .cdn_distribution import * +from .dns_record_set import * +from .dns_zone import * +from .get_affinity_group import * +from .get_cdn_custom_domain import * +from .get_cdn_distribution import * +from .get_dns_record_set import * +from .get_dns_zone import * +from .get_git import * +from .get_image import * +from .get_key_pair import * +from .get_loadbalancer import * +from .get_logme_credential import * +from .get_logme_instance import * +from .get_mariadb_credential import * +from .get_mariadb_instance import * +from .get_mongodbflex_instance import * +from .get_mongodbflex_user import * +from .get_network import * +from .get_network_area import * +from .get_network_area_route import * +from .get_network_interface import * +from .get_objectstorage_bucket import * +from .get_objectstorage_credential import * +from .get_objectstorage_credentials_group import * +from .get_observability_alertgroup import * +from .get_observability_instance import * +from .get_observability_logalertgroup import * +from .get_observability_scrapeconfig import * +from .get_opensearch_credential import * +from .get_opensearch_instance import * +from .get_postgresflex_database import * +from .get_postgresflex_instance import * +from .get_postgresflex_user import * +from .get_public_ip import * +from .get_public_ip_ranges import * +from .get_rabbitmq_credential import * +from .get_rabbitmq_instance import * +from .get_redis_credential import * +from .get_redis_instance import * +from .get_resourcemanager_project import * +from .get_secretsmanager_instance import * +from .get_secretsmanager_user import * +from .get_security_group import * +from .get_security_group_rule import * +from .get_server import * +from .get_server_backup_schedule import * +from .get_server_backup_schedules import * +from .get_server_update_schedule import * +from .get_server_update_schedules import * +from .get_service_account import * +from .get_ske_cluster import * +from .get_sqlserverflex_instance import * +from .get_sqlserverflex_user import * +from .get_volume import * +from .git import * +from .image import * +from .key_pair import * +from .loadbalancer import * +from .loadbalancer_observability_credential import * +from .logme_credential import * +from .logme_instance import * +from .mariadb_credential import * +from .mariadb_instance import * +from .modelserving_token import * +from .mongodbflex_instance import * +from .mongodbflex_user import * +from .network import * +from .network_area import * +from .network_area_route import * +from .network_interface import * +from .objectstorage_bucket import * +from .objectstorage_credential import * +from .objectstorage_credentials_group import * +from .observability_alertgroup import * +from .observability_credential import * +from .observability_instance import * +from .observability_logalertgroup import * +from .observability_scrapeconfig import * +from .opensearch_credential import * +from .opensearch_instance import * +from .postgresflex_database import * +from .postgresflex_instance import * +from .postgresflex_user import * +from .provider import * +from .public_ip import * +from .public_ip_associate import * +from .rabbitmq_credential import * +from .rabbitmq_instance import * +from .redis_credential import * +from .redis_instance import * +from .resourcemanager_project import * +from .secretsmanager_instance import * +from .secretsmanager_user import * +from .security_group import * +from .security_group_rule import * +from .server import * +from .server_backup_schedule import * +from .server_network_interface_attach import * +from .server_service_account_attach import * +from .server_update_schedule import * +from .server_volume_attach import * +from .service_account import * +from .service_account_access_token import * +from .service_account_key import * +from .ske_cluster import * +from .ske_kubeconfig import * +from .sqlserverflex_instance import * +from .sqlserverflex_user import * +from .volume import * +from ._inputs import * +from . import outputs + +# Make subpackages available: +if typing.TYPE_CHECKING: + import pulumi_stackit.config as __config + config = __config +else: + config = _utilities.lazy_import('pulumi_stackit.config') + +_utilities.register( + resource_modules=""" +[ + { + "pkg": "stackit", + "mod": "index/affinityGroup", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/affinityGroup:AffinityGroup": "AffinityGroup" + } + }, + { + "pkg": "stackit", + "mod": "index/authorizationOrganizationRoleAssignment", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment": "AuthorizationOrganizationRoleAssignment" + } + }, + { + "pkg": "stackit", + "mod": "index/authorizationProjectRoleAssignment", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment": "AuthorizationProjectRoleAssignment" + } + }, + { + "pkg": "stackit", + "mod": "index/cdnCustomDomain", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/cdnCustomDomain:CdnCustomDomain": "CdnCustomDomain" + } + }, + { + "pkg": "stackit", + "mod": "index/cdnDistribution", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/cdnDistribution:CdnDistribution": "CdnDistribution" + } + }, + { + "pkg": "stackit", + "mod": "index/dnsRecordSet", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/dnsRecordSet:DnsRecordSet": "DnsRecordSet" + } + }, + { + "pkg": "stackit", + "mod": "index/dnsZone", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/dnsZone:DnsZone": "DnsZone" + } + }, + { + "pkg": "stackit", + "mod": "index/git", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/git:Git": "Git" + } + }, + { + "pkg": "stackit", + "mod": "index/image", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/image:Image": "Image" + } + }, + { + "pkg": "stackit", + "mod": "index/keyPair", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/keyPair:KeyPair": "KeyPair" + } + }, + { + "pkg": "stackit", + "mod": "index/loadbalancer", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/loadbalancer:Loadbalancer": "Loadbalancer" + } + }, + { + "pkg": "stackit", + "mod": "index/loadbalancerObservabilityCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential": "LoadbalancerObservabilityCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/logmeCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/logmeCredential:LogmeCredential": "LogmeCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/logmeInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/logmeInstance:LogmeInstance": "LogmeInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/mariadbCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/mariadbCredential:MariadbCredential": "MariadbCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/mariadbInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/mariadbInstance:MariadbInstance": "MariadbInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/modelservingToken", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/modelservingToken:ModelservingToken": "ModelservingToken" + } + }, + { + "pkg": "stackit", + "mod": "index/mongodbflexInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/mongodbflexInstance:MongodbflexInstance": "MongodbflexInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/mongodbflexUser", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/mongodbflexUser:MongodbflexUser": "MongodbflexUser" + } + }, + { + "pkg": "stackit", + "mod": "index/network", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/network:Network": "Network" + } + }, + { + "pkg": "stackit", + "mod": "index/networkArea", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/networkArea:NetworkArea": "NetworkArea" + } + }, + { + "pkg": "stackit", + "mod": "index/networkAreaRoute", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/networkAreaRoute:NetworkAreaRoute": "NetworkAreaRoute" + } + }, + { + "pkg": "stackit", + "mod": "index/networkInterface", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/networkInterface:NetworkInterface": "NetworkInterface" + } + }, + { + "pkg": "stackit", + "mod": "index/objectstorageBucket", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/objectstorageBucket:ObjectstorageBucket": "ObjectstorageBucket" + } + }, + { + "pkg": "stackit", + "mod": "index/objectstorageCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/objectstorageCredential:ObjectstorageCredential": "ObjectstorageCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/objectstorageCredentialsGroup", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup": "ObjectstorageCredentialsGroup" + } + }, + { + "pkg": "stackit", + "mod": "index/observabilityAlertgroup", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/observabilityAlertgroup:ObservabilityAlertgroup": "ObservabilityAlertgroup" + } + }, + { + "pkg": "stackit", + "mod": "index/observabilityCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/observabilityCredential:ObservabilityCredential": "ObservabilityCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/observabilityInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/observabilityInstance:ObservabilityInstance": "ObservabilityInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/observabilityLogalertgroup", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup": "ObservabilityLogalertgroup" + } + }, + { + "pkg": "stackit", + "mod": "index/observabilityScrapeconfig", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig": "ObservabilityScrapeconfig" + } + }, + { + "pkg": "stackit", + "mod": "index/opensearchCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/opensearchCredential:OpensearchCredential": "OpensearchCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/opensearchInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/opensearchInstance:OpensearchInstance": "OpensearchInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/postgresflexDatabase", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/postgresflexDatabase:PostgresflexDatabase": "PostgresflexDatabase" + } + }, + { + "pkg": "stackit", + "mod": "index/postgresflexInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/postgresflexInstance:PostgresflexInstance": "PostgresflexInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/postgresflexUser", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/postgresflexUser:PostgresflexUser": "PostgresflexUser" + } + }, + { + "pkg": "stackit", + "mod": "index/publicIp", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/publicIp:PublicIp": "PublicIp" + } + }, + { + "pkg": "stackit", + "mod": "index/publicIpAssociate", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/publicIpAssociate:PublicIpAssociate": "PublicIpAssociate" + } + }, + { + "pkg": "stackit", + "mod": "index/rabbitmqCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/rabbitmqCredential:RabbitmqCredential": "RabbitmqCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/rabbitmqInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/rabbitmqInstance:RabbitmqInstance": "RabbitmqInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/redisCredential", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/redisCredential:RedisCredential": "RedisCredential" + } + }, + { + "pkg": "stackit", + "mod": "index/redisInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/redisInstance:RedisInstance": "RedisInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/resourcemanagerProject", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/resourcemanagerProject:ResourcemanagerProject": "ResourcemanagerProject" + } + }, + { + "pkg": "stackit", + "mod": "index/secretsmanagerInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/secretsmanagerInstance:SecretsmanagerInstance": "SecretsmanagerInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/secretsmanagerUser", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/secretsmanagerUser:SecretsmanagerUser": "SecretsmanagerUser" + } + }, + { + "pkg": "stackit", + "mod": "index/securityGroup", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/securityGroup:SecurityGroup": "SecurityGroup" + } + }, + { + "pkg": "stackit", + "mod": "index/securityGroupRule", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/securityGroupRule:SecurityGroupRule": "SecurityGroupRule" + } + }, + { + "pkg": "stackit", + "mod": "index/server", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/server:Server": "Server" + } + }, + { + "pkg": "stackit", + "mod": "index/serverBackupSchedule", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serverBackupSchedule:ServerBackupSchedule": "ServerBackupSchedule" + } + }, + { + "pkg": "stackit", + "mod": "index/serverNetworkInterfaceAttach", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach": "ServerNetworkInterfaceAttach" + } + }, + { + "pkg": "stackit", + "mod": "index/serverServiceAccountAttach", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach": "ServerServiceAccountAttach" + } + }, + { + "pkg": "stackit", + "mod": "index/serverUpdateSchedule", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serverUpdateSchedule:ServerUpdateSchedule": "ServerUpdateSchedule" + } + }, + { + "pkg": "stackit", + "mod": "index/serverVolumeAttach", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serverVolumeAttach:ServerVolumeAttach": "ServerVolumeAttach" + } + }, + { + "pkg": "stackit", + "mod": "index/serviceAccount", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serviceAccount:ServiceAccount": "ServiceAccount" + } + }, + { + "pkg": "stackit", + "mod": "index/serviceAccountAccessToken", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken": "ServiceAccountAccessToken" + } + }, + { + "pkg": "stackit", + "mod": "index/serviceAccountKey", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/serviceAccountKey:ServiceAccountKey": "ServiceAccountKey" + } + }, + { + "pkg": "stackit", + "mod": "index/skeCluster", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/skeCluster:SkeCluster": "SkeCluster" + } + }, + { + "pkg": "stackit", + "mod": "index/skeKubeconfig", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/skeKubeconfig:SkeKubeconfig": "SkeKubeconfig" + } + }, + { + "pkg": "stackit", + "mod": "index/sqlserverflexInstance", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/sqlserverflexInstance:SqlserverflexInstance": "SqlserverflexInstance" + } + }, + { + "pkg": "stackit", + "mod": "index/sqlserverflexUser", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/sqlserverflexUser:SqlserverflexUser": "SqlserverflexUser" + } + }, + { + "pkg": "stackit", + "mod": "index/volume", + "fqn": "pulumi_stackit", + "classes": { + "stackit:index/volume:Volume": "Volume" + } + } +] +""", + resource_packages=""" +[ + { + "pkg": "stackit", + "token": "pulumi:providers:stackit", + "fqn": "pulumi_stackit", + "class": "Provider" + } +] +""" +) diff --git a/sdk/python/pulumi_stackit/_inputs.py b/sdk/python/pulumi_stackit/_inputs.py new file mode 100644 index 0000000..9dce3f8 --- /dev/null +++ b/sdk/python/pulumi_stackit/_inputs.py @@ -0,0 +1,5926 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'CdnDistributionConfigArgs', + 'CdnDistributionConfigArgsDict', + 'CdnDistributionConfigBackendArgs', + 'CdnDistributionConfigBackendArgsDict', + 'CdnDistributionDomainArgs', + 'CdnDistributionDomainArgsDict', + 'ImageChecksumArgs', + 'ImageChecksumArgsDict', + 'ImageConfigArgs', + 'ImageConfigArgsDict', + 'LoadbalancerListenerArgs', + 'LoadbalancerListenerArgsDict', + 'LoadbalancerListenerServerNameIndicatorArgs', + 'LoadbalancerListenerServerNameIndicatorArgsDict', + 'LoadbalancerNetworkArgs', + 'LoadbalancerNetworkArgsDict', + 'LoadbalancerOptionsArgs', + 'LoadbalancerOptionsArgsDict', + 'LoadbalancerOptionsObservabilityArgs', + 'LoadbalancerOptionsObservabilityArgsDict', + 'LoadbalancerOptionsObservabilityLogsArgs', + 'LoadbalancerOptionsObservabilityLogsArgsDict', + 'LoadbalancerOptionsObservabilityMetricsArgs', + 'LoadbalancerOptionsObservabilityMetricsArgsDict', + 'LoadbalancerTargetPoolArgs', + 'LoadbalancerTargetPoolArgsDict', + 'LoadbalancerTargetPoolActiveHealthCheckArgs', + 'LoadbalancerTargetPoolActiveHealthCheckArgsDict', + 'LoadbalancerTargetPoolSessionPersistenceArgs', + 'LoadbalancerTargetPoolSessionPersistenceArgsDict', + 'LoadbalancerTargetPoolTargetArgs', + 'LoadbalancerTargetPoolTargetArgsDict', + 'LogmeInstanceParametersArgs', + 'LogmeInstanceParametersArgsDict', + 'MariadbInstanceParametersArgs', + 'MariadbInstanceParametersArgsDict', + 'MongodbflexInstanceFlavorArgs', + 'MongodbflexInstanceFlavorArgsDict', + 'MongodbflexInstanceOptionsArgs', + 'MongodbflexInstanceOptionsArgsDict', + 'MongodbflexInstanceStorageArgs', + 'MongodbflexInstanceStorageArgsDict', + 'NetworkAreaNetworkRangeArgs', + 'NetworkAreaNetworkRangeArgsDict', + 'ObservabilityAlertgroupRuleArgs', + 'ObservabilityAlertgroupRuleArgsDict', + 'ObservabilityInstanceAlertConfigArgs', + 'ObservabilityInstanceAlertConfigArgsDict', + 'ObservabilityInstanceAlertConfigGlobalArgs', + 'ObservabilityInstanceAlertConfigGlobalArgsDict', + 'ObservabilityInstanceAlertConfigReceiverArgs', + 'ObservabilityInstanceAlertConfigReceiverArgsDict', + 'ObservabilityInstanceAlertConfigReceiverEmailConfigArgs', + 'ObservabilityInstanceAlertConfigReceiverEmailConfigArgsDict', + 'ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs', + 'ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgsDict', + 'ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs', + 'ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgsDict', + 'ObservabilityInstanceAlertConfigRouteArgs', + 'ObservabilityInstanceAlertConfigRouteArgsDict', + 'ObservabilityInstanceAlertConfigRouteRouteArgs', + 'ObservabilityInstanceAlertConfigRouteRouteArgsDict', + 'ObservabilityLogalertgroupRuleArgs', + 'ObservabilityLogalertgroupRuleArgsDict', + 'ObservabilityScrapeconfigBasicAuthArgs', + 'ObservabilityScrapeconfigBasicAuthArgsDict', + 'ObservabilityScrapeconfigSaml2Args', + 'ObservabilityScrapeconfigSaml2ArgsDict', + 'ObservabilityScrapeconfigTargetArgs', + 'ObservabilityScrapeconfigTargetArgsDict', + 'OpensearchInstanceParametersArgs', + 'OpensearchInstanceParametersArgsDict', + 'PostgresflexInstanceFlavorArgs', + 'PostgresflexInstanceFlavorArgsDict', + 'PostgresflexInstanceStorageArgs', + 'PostgresflexInstanceStorageArgsDict', + 'RabbitmqInstanceParametersArgs', + 'RabbitmqInstanceParametersArgsDict', + 'RedisInstanceParametersArgs', + 'RedisInstanceParametersArgsDict', + 'SecurityGroupRuleIcmpParametersArgs', + 'SecurityGroupRuleIcmpParametersArgsDict', + 'SecurityGroupRulePortRangeArgs', + 'SecurityGroupRulePortRangeArgsDict', + 'SecurityGroupRuleProtocolArgs', + 'SecurityGroupRuleProtocolArgsDict', + 'ServerBackupScheduleBackupPropertiesArgs', + 'ServerBackupScheduleBackupPropertiesArgsDict', + 'ServerBootVolumeArgs', + 'ServerBootVolumeArgsDict', + 'SkeClusterExtensionsArgs', + 'SkeClusterExtensionsArgsDict', + 'SkeClusterExtensionsAclArgs', + 'SkeClusterExtensionsAclArgsDict', + 'SkeClusterExtensionsArgusArgs', + 'SkeClusterExtensionsArgusArgsDict', + 'SkeClusterExtensionsDnsArgs', + 'SkeClusterExtensionsDnsArgsDict', + 'SkeClusterHibernationArgs', + 'SkeClusterHibernationArgsDict', + 'SkeClusterMaintenanceArgs', + 'SkeClusterMaintenanceArgsDict', + 'SkeClusterNetworkArgs', + 'SkeClusterNetworkArgsDict', + 'SkeClusterNodePoolArgs', + 'SkeClusterNodePoolArgsDict', + 'SkeClusterNodePoolTaintArgs', + 'SkeClusterNodePoolTaintArgsDict', + 'SqlserverflexInstanceFlavorArgs', + 'SqlserverflexInstanceFlavorArgsDict', + 'SqlserverflexInstanceOptionsArgs', + 'SqlserverflexInstanceOptionsArgsDict', + 'SqlserverflexInstanceStorageArgs', + 'SqlserverflexInstanceStorageArgsDict', + 'VolumeSourceArgs', + 'VolumeSourceArgsDict', +] + +MYPY = False + +if not MYPY: + class CdnDistributionConfigArgsDict(TypedDict): + backend: pulumi.Input['CdnDistributionConfigBackendArgsDict'] + """ + The configured backend for the distribution + """ + regions: pulumi.Input[Sequence[pulumi.Input[builtins.str]]] + """ + The configured regions where content will be hosted + """ +elif False: + CdnDistributionConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CdnDistributionConfigArgs: + def __init__(__self__, *, + backend: pulumi.Input['CdnDistributionConfigBackendArgs'], + regions: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + """ + :param pulumi.Input['CdnDistributionConfigBackendArgs'] backend: The configured backend for the distribution + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] regions: The configured regions where content will be hosted + """ + pulumi.set(__self__, "backend", backend) + pulumi.set(__self__, "regions", regions) + + @property + @pulumi.getter + def backend(self) -> pulumi.Input['CdnDistributionConfigBackendArgs']: + """ + The configured backend for the distribution + """ + return pulumi.get(self, "backend") + + @backend.setter + def backend(self, value: pulumi.Input['CdnDistributionConfigBackendArgs']): + pulumi.set(self, "backend", value) + + @property + @pulumi.getter + def regions(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + The configured regions where content will be hosted + """ + return pulumi.get(self, "regions") + + @regions.setter + def regions(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "regions", value) + + +if not MYPY: + class CdnDistributionConfigBackendArgsDict(TypedDict): + origin_url: pulumi.Input[builtins.str] + """ + The configured backend type for the distribution + """ + type: pulumi.Input[builtins.str] + """ + The configured backend type. Supported values are: `http`. + """ + origin_request_headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + The configured origin request headers for the backend + """ +elif False: + CdnDistributionConfigBackendArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CdnDistributionConfigBackendArgs: + def __init__(__self__, *, + origin_url: pulumi.Input[builtins.str], + type: pulumi.Input[builtins.str], + origin_request_headers: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.str] origin_url: The configured backend type for the distribution + :param pulumi.Input[builtins.str] type: The configured backend type. Supported values are: `http`. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] origin_request_headers: The configured origin request headers for the backend + """ + pulumi.set(__self__, "origin_url", origin_url) + pulumi.set(__self__, "type", type) + if origin_request_headers is not None: + pulumi.set(__self__, "origin_request_headers", origin_request_headers) + + @property + @pulumi.getter(name="originUrl") + def origin_url(self) -> pulumi.Input[builtins.str]: + """ + The configured backend type for the distribution + """ + return pulumi.get(self, "origin_url") + + @origin_url.setter + def origin_url(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "origin_url", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[builtins.str]: + """ + The configured backend type. Supported values are: `http`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="originRequestHeaders") + def origin_request_headers(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + The configured origin request headers for the backend + """ + return pulumi.get(self, "origin_request_headers") + + @origin_request_headers.setter + def origin_request_headers(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "origin_request_headers", value) + + +if not MYPY: + class CdnDistributionDomainArgsDict(TypedDict): + errors: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of domain errors + """ + name: NotRequired[pulumi.Input[builtins.str]] + """ + The name of the domain + """ + status: NotRequired[pulumi.Input[builtins.str]] + """ + The status of the domain + """ + type: NotRequired[pulumi.Input[builtins.str]] + """ + The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ +elif False: + CdnDistributionDomainArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class CdnDistributionDomainArgs: + def __init__(__self__, *, + errors: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + status: Optional[pulumi.Input[builtins.str]] = None, + type: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] errors: List of domain errors + :param pulumi.Input[builtins.str] name: The name of the domain + :param pulumi.Input[builtins.str] status: The status of the domain + :param pulumi.Input[builtins.str] type: The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + if errors is not None: + pulumi.set(__self__, "errors", errors) + if name is not None: + pulumi.set(__self__, "name", name) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def errors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of domain errors + """ + return pulumi.get(self, "errors") + + @errors.setter + def errors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "errors", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the domain + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The status of the domain + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "status", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "type", value) + + +if not MYPY: + class ImageChecksumArgsDict(TypedDict): + algorithm: NotRequired[pulumi.Input[builtins.str]] + """ + Algorithm for the checksum of the image data. + """ + digest: NotRequired[pulumi.Input[builtins.str]] + """ + Hexdigest of the checksum of the image data. + """ +elif False: + ImageChecksumArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ImageChecksumArgs: + def __init__(__self__, *, + algorithm: Optional[pulumi.Input[builtins.str]] = None, + digest: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] algorithm: Algorithm for the checksum of the image data. + :param pulumi.Input[builtins.str] digest: Hexdigest of the checksum of the image data. + """ + if algorithm is not None: + pulumi.set(__self__, "algorithm", algorithm) + if digest is not None: + pulumi.set(__self__, "digest", digest) + + @property + @pulumi.getter + def algorithm(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Algorithm for the checksum of the image data. + """ + return pulumi.get(self, "algorithm") + + @algorithm.setter + def algorithm(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "algorithm", value) + + @property + @pulumi.getter + def digest(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Hexdigest of the checksum of the image data. + """ + return pulumi.get(self, "digest") + + @digest.setter + def digest(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "digest", value) + + +if not MYPY: + class ImageConfigArgsDict(TypedDict): + boot_menu: NotRequired[pulumi.Input[builtins.bool]] + """ + Enables the BIOS bootmenu. + """ + cdrom_bus: NotRequired[pulumi.Input[builtins.str]] + """ + Sets CDROM bus controller type. + """ + disk_bus: NotRequired[pulumi.Input[builtins.str]] + """ + Sets Disk bus controller type. + """ + nic_model: NotRequired[pulumi.Input[builtins.str]] + """ + Sets virtual network interface model. + """ + operating_system: NotRequired[pulumi.Input[builtins.str]] + """ + Enables operating system specific optimizations. + """ + operating_system_distro: NotRequired[pulumi.Input[builtins.str]] + """ + Operating system distribution. + """ + operating_system_version: NotRequired[pulumi.Input[builtins.str]] + """ + Version of the operating system. + """ + rescue_bus: NotRequired[pulumi.Input[builtins.str]] + """ + Sets the device bus when the image is used as a rescue image. + """ + rescue_device: NotRequired[pulumi.Input[builtins.str]] + """ + Sets the device when the image is used as a rescue image. + """ + secure_boot: NotRequired[pulumi.Input[builtins.bool]] + """ + Enables Secure Boot. + """ + uefi: NotRequired[pulumi.Input[builtins.bool]] + """ + Enables UEFI boot. + """ + video_model: NotRequired[pulumi.Input[builtins.str]] + """ + Sets Graphic device model. + """ + virtio_scsi: NotRequired[pulumi.Input[builtins.bool]] + """ + Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ +elif False: + ImageConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ImageConfigArgs: + def __init__(__self__, *, + boot_menu: Optional[pulumi.Input[builtins.bool]] = None, + cdrom_bus: Optional[pulumi.Input[builtins.str]] = None, + disk_bus: Optional[pulumi.Input[builtins.str]] = None, + nic_model: Optional[pulumi.Input[builtins.str]] = None, + operating_system: Optional[pulumi.Input[builtins.str]] = None, + operating_system_distro: Optional[pulumi.Input[builtins.str]] = None, + operating_system_version: Optional[pulumi.Input[builtins.str]] = None, + rescue_bus: Optional[pulumi.Input[builtins.str]] = None, + rescue_device: Optional[pulumi.Input[builtins.str]] = None, + secure_boot: Optional[pulumi.Input[builtins.bool]] = None, + uefi: Optional[pulumi.Input[builtins.bool]] = None, + video_model: Optional[pulumi.Input[builtins.str]] = None, + virtio_scsi: Optional[pulumi.Input[builtins.bool]] = None): + """ + :param pulumi.Input[builtins.bool] boot_menu: Enables the BIOS bootmenu. + :param pulumi.Input[builtins.str] cdrom_bus: Sets CDROM bus controller type. + :param pulumi.Input[builtins.str] disk_bus: Sets Disk bus controller type. + :param pulumi.Input[builtins.str] nic_model: Sets virtual network interface model. + :param pulumi.Input[builtins.str] operating_system: Enables operating system specific optimizations. + :param pulumi.Input[builtins.str] operating_system_distro: Operating system distribution. + :param pulumi.Input[builtins.str] operating_system_version: Version of the operating system. + :param pulumi.Input[builtins.str] rescue_bus: Sets the device bus when the image is used as a rescue image. + :param pulumi.Input[builtins.str] rescue_device: Sets the device when the image is used as a rescue image. + :param pulumi.Input[builtins.bool] secure_boot: Enables Secure Boot. + :param pulumi.Input[builtins.bool] uefi: Enables UEFI boot. + :param pulumi.Input[builtins.str] video_model: Sets Graphic device model. + :param pulumi.Input[builtins.bool] virtio_scsi: Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + if boot_menu is not None: + pulumi.set(__self__, "boot_menu", boot_menu) + if cdrom_bus is not None: + pulumi.set(__self__, "cdrom_bus", cdrom_bus) + if disk_bus is not None: + pulumi.set(__self__, "disk_bus", disk_bus) + if nic_model is not None: + pulumi.set(__self__, "nic_model", nic_model) + if operating_system is not None: + pulumi.set(__self__, "operating_system", operating_system) + if operating_system_distro is not None: + pulumi.set(__self__, "operating_system_distro", operating_system_distro) + if operating_system_version is not None: + pulumi.set(__self__, "operating_system_version", operating_system_version) + if rescue_bus is not None: + pulumi.set(__self__, "rescue_bus", rescue_bus) + if rescue_device is not None: + pulumi.set(__self__, "rescue_device", rescue_device) + if secure_boot is not None: + pulumi.set(__self__, "secure_boot", secure_boot) + if uefi is not None: + pulumi.set(__self__, "uefi", uefi) + if video_model is not None: + pulumi.set(__self__, "video_model", video_model) + if virtio_scsi is not None: + pulumi.set(__self__, "virtio_scsi", virtio_scsi) + + @property + @pulumi.getter(name="bootMenu") + def boot_menu(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enables the BIOS bootmenu. + """ + return pulumi.get(self, "boot_menu") + + @boot_menu.setter + def boot_menu(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "boot_menu", value) + + @property + @pulumi.getter(name="cdromBus") + def cdrom_bus(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets CDROM bus controller type. + """ + return pulumi.get(self, "cdrom_bus") + + @cdrom_bus.setter + def cdrom_bus(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cdrom_bus", value) + + @property + @pulumi.getter(name="diskBus") + def disk_bus(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets Disk bus controller type. + """ + return pulumi.get(self, "disk_bus") + + @disk_bus.setter + def disk_bus(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "disk_bus", value) + + @property + @pulumi.getter(name="nicModel") + def nic_model(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets virtual network interface model. + """ + return pulumi.get(self, "nic_model") + + @nic_model.setter + def nic_model(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "nic_model", value) + + @property + @pulumi.getter(name="operatingSystem") + def operating_system(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Enables operating system specific optimizations. + """ + return pulumi.get(self, "operating_system") + + @operating_system.setter + def operating_system(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "operating_system", value) + + @property + @pulumi.getter(name="operatingSystemDistro") + def operating_system_distro(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Operating system distribution. + """ + return pulumi.get(self, "operating_system_distro") + + @operating_system_distro.setter + def operating_system_distro(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "operating_system_distro", value) + + @property + @pulumi.getter(name="operatingSystemVersion") + def operating_system_version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Version of the operating system. + """ + return pulumi.get(self, "operating_system_version") + + @operating_system_version.setter + def operating_system_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "operating_system_version", value) + + @property + @pulumi.getter(name="rescueBus") + def rescue_bus(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets the device bus when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_bus") + + @rescue_bus.setter + def rescue_bus(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "rescue_bus", value) + + @property + @pulumi.getter(name="rescueDevice") + def rescue_device(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets the device when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_device") + + @rescue_device.setter + def rescue_device(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "rescue_device", value) + + @property + @pulumi.getter(name="secureBoot") + def secure_boot(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enables Secure Boot. + """ + return pulumi.get(self, "secure_boot") + + @secure_boot.setter + def secure_boot(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "secure_boot", value) + + @property + @pulumi.getter + def uefi(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enables UEFI boot. + """ + return pulumi.get(self, "uefi") + + @uefi.setter + def uefi(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "uefi", value) + + @property + @pulumi.getter(name="videoModel") + def video_model(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Sets Graphic device model. + """ + return pulumi.get(self, "video_model") + + @video_model.setter + def video_model(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "video_model", value) + + @property + @pulumi.getter(name="virtioScsi") + def virtio_scsi(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + return pulumi.get(self, "virtio_scsi") + + @virtio_scsi.setter + def virtio_scsi(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "virtio_scsi", value) + + +if not MYPY: + class LoadbalancerListenerArgsDict(TypedDict): + port: pulumi.Input[builtins.int] + """ + Port number where we listen for traffic. + """ + protocol: pulumi.Input[builtins.str] + """ + Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + """ + target_pool: pulumi.Input[builtins.str] + """ + Reference target pool by target pool name. + """ + display_name: NotRequired[pulumi.Input[builtins.str]] + server_name_indicators: NotRequired[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerServerNameIndicatorArgsDict']]]] + """ + A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ +elif False: + LoadbalancerListenerArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerListenerArgs: + def __init__(__self__, *, + port: pulumi.Input[builtins.int], + protocol: pulumi.Input[builtins.str], + target_pool: pulumi.Input[builtins.str], + display_name: Optional[pulumi.Input[builtins.str]] = None, + server_name_indicators: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerServerNameIndicatorArgs']]]] = None): + """ + :param pulumi.Input[builtins.int] port: Port number where we listen for traffic. + :param pulumi.Input[builtins.str] protocol: Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + :param pulumi.Input[builtins.str] target_pool: Reference target pool by target pool name. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerServerNameIndicatorArgs']]] server_name_indicators: A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "protocol", protocol) + pulumi.set(__self__, "target_pool", target_pool) + if display_name is not None: + pulumi.set(__self__, "display_name", display_name) + if server_name_indicators is not None: + pulumi.set(__self__, "server_name_indicators", server_name_indicators) + + @property + @pulumi.getter + def port(self) -> pulumi.Input[builtins.int]: + """ + Port number where we listen for traffic. + """ + return pulumi.get(self, "port") + + @port.setter + def port(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter + def protocol(self) -> pulumi.Input[builtins.str]: + """ + Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + """ + return pulumi.get(self, "protocol") + + @protocol.setter + def protocol(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "protocol", value) + + @property + @pulumi.getter(name="targetPool") + def target_pool(self) -> pulumi.Input[builtins.str]: + """ + Reference target pool by target pool name. + """ + return pulumi.get(self, "target_pool") + + @target_pool.setter + def target_pool(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "target_pool", value) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "display_name") + + @display_name.setter + def display_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "display_name", value) + + @property + @pulumi.getter(name="serverNameIndicators") + def server_name_indicators(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerServerNameIndicatorArgs']]]]: + """ + A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "server_name_indicators") + + @server_name_indicators.setter + def server_name_indicators(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerServerNameIndicatorArgs']]]]): + pulumi.set(self, "server_name_indicators", value) + + +if not MYPY: + class LoadbalancerListenerServerNameIndicatorArgsDict(TypedDict): + name: NotRequired[pulumi.Input[builtins.str]] + """ + A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ +elif False: + LoadbalancerListenerServerNameIndicatorArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerListenerServerNameIndicatorArgs: + def __init__(__self__, *, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] name: A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +if not MYPY: + class LoadbalancerNetworkArgsDict(TypedDict): + network_id: pulumi.Input[builtins.str] + """ + Openstack network ID. + """ + role: pulumi.Input[builtins.str] + """ + The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + """ +elif False: + LoadbalancerNetworkArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerNetworkArgs: + def __init__(__self__, *, + network_id: pulumi.Input[builtins.str], + role: pulumi.Input[builtins.str]): + """ + :param pulumi.Input[builtins.str] network_id: Openstack network ID. + :param pulumi.Input[builtins.str] role: The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + """ + pulumi.set(__self__, "network_id", network_id) + pulumi.set(__self__, "role", role) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> pulumi.Input[builtins.str]: + """ + Openstack network ID. + """ + return pulumi.get(self, "network_id") + + @network_id.setter + def network_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "network_id", value) + + @property + @pulumi.getter + def role(self) -> pulumi.Input[builtins.str]: + """ + The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "role", value) + + +if not MYPY: + class LoadbalancerOptionsArgsDict(TypedDict): + acls: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + Load Balancer is accessible only from an IP address in this range. + """ + observability: NotRequired[pulumi.Input['LoadbalancerOptionsObservabilityArgsDict']] + """ + We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + """ + private_network_only: NotRequired[pulumi.Input[builtins.bool]] + """ + If true, Load Balancer is accessible only via a private network IP address. + """ +elif False: + LoadbalancerOptionsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerOptionsArgs: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + observability: Optional[pulumi.Input['LoadbalancerOptionsObservabilityArgs']] = None, + private_network_only: Optional[pulumi.Input[builtins.bool]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: Load Balancer is accessible only from an IP address in this range. + :param pulumi.Input['LoadbalancerOptionsObservabilityArgs'] observability: We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + :param pulumi.Input[builtins.bool] private_network_only: If true, Load Balancer is accessible only via a private network IP address. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if observability is not None: + pulumi.set(__self__, "observability", observability) + if private_network_only is not None: + pulumi.set(__self__, "private_network_only", private_network_only) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Load Balancer is accessible only from an IP address in this range. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter + def observability(self) -> Optional[pulumi.Input['LoadbalancerOptionsObservabilityArgs']]: + """ + We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + """ + return pulumi.get(self, "observability") + + @observability.setter + def observability(self, value: Optional[pulumi.Input['LoadbalancerOptionsObservabilityArgs']]): + pulumi.set(self, "observability", value) + + @property + @pulumi.getter(name="privateNetworkOnly") + def private_network_only(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If true, Load Balancer is accessible only via a private network IP address. + """ + return pulumi.get(self, "private_network_only") + + @private_network_only.setter + def private_network_only(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "private_network_only", value) + + +if not MYPY: + class LoadbalancerOptionsObservabilityArgsDict(TypedDict): + logs: NotRequired[pulumi.Input['LoadbalancerOptionsObservabilityLogsArgsDict']] + """ + Observability logs configuration. Not changeable after creation. + """ + metrics: NotRequired[pulumi.Input['LoadbalancerOptionsObservabilityMetricsArgsDict']] + """ + Observability metrics configuration. Not changeable after creation. + """ +elif False: + LoadbalancerOptionsObservabilityArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerOptionsObservabilityArgs: + def __init__(__self__, *, + logs: Optional[pulumi.Input['LoadbalancerOptionsObservabilityLogsArgs']] = None, + metrics: Optional[pulumi.Input['LoadbalancerOptionsObservabilityMetricsArgs']] = None): + """ + :param pulumi.Input['LoadbalancerOptionsObservabilityLogsArgs'] logs: Observability logs configuration. Not changeable after creation. + :param pulumi.Input['LoadbalancerOptionsObservabilityMetricsArgs'] metrics: Observability metrics configuration. Not changeable after creation. + """ + if logs is not None: + pulumi.set(__self__, "logs", logs) + if metrics is not None: + pulumi.set(__self__, "metrics", metrics) + + @property + @pulumi.getter + def logs(self) -> Optional[pulumi.Input['LoadbalancerOptionsObservabilityLogsArgs']]: + """ + Observability logs configuration. Not changeable after creation. + """ + return pulumi.get(self, "logs") + + @logs.setter + def logs(self, value: Optional[pulumi.Input['LoadbalancerOptionsObservabilityLogsArgs']]): + pulumi.set(self, "logs", value) + + @property + @pulumi.getter + def metrics(self) -> Optional[pulumi.Input['LoadbalancerOptionsObservabilityMetricsArgs']]: + """ + Observability metrics configuration. Not changeable after creation. + """ + return pulumi.get(self, "metrics") + + @metrics.setter + def metrics(self, value: Optional[pulumi.Input['LoadbalancerOptionsObservabilityMetricsArgs']]): + pulumi.set(self, "metrics", value) + + +if not MYPY: + class LoadbalancerOptionsObservabilityLogsArgsDict(TypedDict): + credentials_ref: NotRequired[pulumi.Input[builtins.str]] + """ + Credentials reference for logs. Not changeable after creation. + """ + push_url: NotRequired[pulumi.Input[builtins.str]] + """ + Credentials reference for logs. Not changeable after creation. + """ +elif False: + LoadbalancerOptionsObservabilityLogsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerOptionsObservabilityLogsArgs: + def __init__(__self__, *, + credentials_ref: Optional[pulumi.Input[builtins.str]] = None, + push_url: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] credentials_ref: Credentials reference for logs. Not changeable after creation. + :param pulumi.Input[builtins.str] push_url: Credentials reference for logs. Not changeable after creation. + """ + if credentials_ref is not None: + pulumi.set(__self__, "credentials_ref", credentials_ref) + if push_url is not None: + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credentials reference for logs. Not changeable after creation. + """ + return pulumi.get(self, "credentials_ref") + + @credentials_ref.setter + def credentials_ref(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_ref", value) + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credentials reference for logs. Not changeable after creation. + """ + return pulumi.get(self, "push_url") + + @push_url.setter + def push_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "push_url", value) + + +if not MYPY: + class LoadbalancerOptionsObservabilityMetricsArgsDict(TypedDict): + credentials_ref: NotRequired[pulumi.Input[builtins.str]] + """ + Credentials reference for metrics. Not changeable after creation. + """ + push_url: NotRequired[pulumi.Input[builtins.str]] + """ + Credentials reference for metrics. Not changeable after creation. + """ +elif False: + LoadbalancerOptionsObservabilityMetricsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerOptionsObservabilityMetricsArgs: + def __init__(__self__, *, + credentials_ref: Optional[pulumi.Input[builtins.str]] = None, + push_url: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] credentials_ref: Credentials reference for metrics. Not changeable after creation. + :param pulumi.Input[builtins.str] push_url: Credentials reference for metrics. Not changeable after creation. + """ + if credentials_ref is not None: + pulumi.set(__self__, "credentials_ref", credentials_ref) + if push_url is not None: + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credentials reference for metrics. Not changeable after creation. + """ + return pulumi.get(self, "credentials_ref") + + @credentials_ref.setter + def credentials_ref(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_ref", value) + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credentials reference for metrics. Not changeable after creation. + """ + return pulumi.get(self, "push_url") + + @push_url.setter + def push_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "push_url", value) + + +if not MYPY: + class LoadbalancerTargetPoolArgsDict(TypedDict): + name: pulumi.Input[builtins.str] + """ + Target pool name. + """ + target_port: pulumi.Input[builtins.int] + """ + Identical port number where each target listens for traffic. + """ + targets: pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolTargetArgsDict']]] + """ + List of all targets which will be used in the pool. Limited to 1000. + """ + active_health_check: NotRequired[pulumi.Input['LoadbalancerTargetPoolActiveHealthCheckArgsDict']] + session_persistence: NotRequired[pulumi.Input['LoadbalancerTargetPoolSessionPersistenceArgsDict']] + """ + Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ +elif False: + LoadbalancerTargetPoolArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerTargetPoolArgs: + def __init__(__self__, *, + name: pulumi.Input[builtins.str], + target_port: pulumi.Input[builtins.int], + targets: pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolTargetArgs']]], + active_health_check: Optional[pulumi.Input['LoadbalancerTargetPoolActiveHealthCheckArgs']] = None, + session_persistence: Optional[pulumi.Input['LoadbalancerTargetPoolSessionPersistenceArgs']] = None): + """ + :param pulumi.Input[builtins.str] name: Target pool name. + :param pulumi.Input[builtins.int] target_port: Identical port number where each target listens for traffic. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolTargetArgs']]] targets: List of all targets which will be used in the pool. Limited to 1000. + :param pulumi.Input['LoadbalancerTargetPoolSessionPersistenceArgs'] session_persistence: Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "target_port", target_port) + pulumi.set(__self__, "targets", targets) + if active_health_check is not None: + pulumi.set(__self__, "active_health_check", active_health_check) + if session_persistence is not None: + pulumi.set(__self__, "session_persistence", session_persistence) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[builtins.str]: + """ + Target pool name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="targetPort") + def target_port(self) -> pulumi.Input[builtins.int]: + """ + Identical port number where each target listens for traffic. + """ + return pulumi.get(self, "target_port") + + @target_port.setter + def target_port(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "target_port", value) + + @property + @pulumi.getter + def targets(self) -> pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolTargetArgs']]]: + """ + List of all targets which will be used in the pool. Limited to 1000. + """ + return pulumi.get(self, "targets") + + @targets.setter + def targets(self, value: pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolTargetArgs']]]): + pulumi.set(self, "targets", value) + + @property + @pulumi.getter(name="activeHealthCheck") + def active_health_check(self) -> Optional[pulumi.Input['LoadbalancerTargetPoolActiveHealthCheckArgs']]: + return pulumi.get(self, "active_health_check") + + @active_health_check.setter + def active_health_check(self, value: Optional[pulumi.Input['LoadbalancerTargetPoolActiveHealthCheckArgs']]): + pulumi.set(self, "active_health_check", value) + + @property + @pulumi.getter(name="sessionPersistence") + def session_persistence(self) -> Optional[pulumi.Input['LoadbalancerTargetPoolSessionPersistenceArgs']]: + """ + Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + return pulumi.get(self, "session_persistence") + + @session_persistence.setter + def session_persistence(self, value: Optional[pulumi.Input['LoadbalancerTargetPoolSessionPersistenceArgs']]): + pulumi.set(self, "session_persistence", value) + + +if not MYPY: + class LoadbalancerTargetPoolActiveHealthCheckArgsDict(TypedDict): + healthy_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + Healthy threshold of the health checking. + """ + interval: NotRequired[pulumi.Input[builtins.str]] + """ + Interval duration of health checking in seconds. + """ + interval_jitter: NotRequired[pulumi.Input[builtins.str]] + """ + Interval duration threshold of the health checking in seconds. + """ + timeout: NotRequired[pulumi.Input[builtins.str]] + """ + Active health checking timeout duration in seconds. + """ + unhealthy_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + Unhealthy threshold of the health checking. + """ +elif False: + LoadbalancerTargetPoolActiveHealthCheckArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerTargetPoolActiveHealthCheckArgs: + def __init__(__self__, *, + healthy_threshold: Optional[pulumi.Input[builtins.int]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + interval_jitter: Optional[pulumi.Input[builtins.str]] = None, + timeout: Optional[pulumi.Input[builtins.str]] = None, + unhealthy_threshold: Optional[pulumi.Input[builtins.int]] = None): + """ + :param pulumi.Input[builtins.int] healthy_threshold: Healthy threshold of the health checking. + :param pulumi.Input[builtins.str] interval: Interval duration of health checking in seconds. + :param pulumi.Input[builtins.str] interval_jitter: Interval duration threshold of the health checking in seconds. + :param pulumi.Input[builtins.str] timeout: Active health checking timeout duration in seconds. + :param pulumi.Input[builtins.int] unhealthy_threshold: Unhealthy threshold of the health checking. + """ + if healthy_threshold is not None: + pulumi.set(__self__, "healthy_threshold", healthy_threshold) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if interval_jitter is not None: + pulumi.set(__self__, "interval_jitter", interval_jitter) + if timeout is not None: + pulumi.set(__self__, "timeout", timeout) + if unhealthy_threshold is not None: + pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold) + + @property + @pulumi.getter(name="healthyThreshold") + def healthy_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Healthy threshold of the health checking. + """ + return pulumi.get(self, "healthy_threshold") + + @healthy_threshold.setter + def healthy_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "healthy_threshold", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Interval duration of health checking in seconds. + """ + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter(name="intervalJitter") + def interval_jitter(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Interval duration threshold of the health checking in seconds. + """ + return pulumi.get(self, "interval_jitter") + + @interval_jitter.setter + def interval_jitter(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval_jitter", value) + + @property + @pulumi.getter + def timeout(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Active health checking timeout duration in seconds. + """ + return pulumi.get(self, "timeout") + + @timeout.setter + def timeout(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "timeout", value) + + @property + @pulumi.getter(name="unhealthyThreshold") + def unhealthy_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Unhealthy threshold of the health checking. + """ + return pulumi.get(self, "unhealthy_threshold") + + @unhealthy_threshold.setter + def unhealthy_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "unhealthy_threshold", value) + + +if not MYPY: + class LoadbalancerTargetPoolSessionPersistenceArgsDict(TypedDict): + use_source_ip_address: NotRequired[pulumi.Input[builtins.bool]] + """ + If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ +elif False: + LoadbalancerTargetPoolSessionPersistenceArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerTargetPoolSessionPersistenceArgs: + def __init__(__self__, *, + use_source_ip_address: Optional[pulumi.Input[builtins.bool]] = None): + """ + :param pulumi.Input[builtins.bool] use_source_ip_address: If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + if use_source_ip_address is not None: + pulumi.set(__self__, "use_source_ip_address", use_source_ip_address) + + @property + @pulumi.getter(name="useSourceIpAddress") + def use_source_ip_address(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + return pulumi.get(self, "use_source_ip_address") + + @use_source_ip_address.setter + def use_source_ip_address(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "use_source_ip_address", value) + + +if not MYPY: + class LoadbalancerTargetPoolTargetArgsDict(TypedDict): + display_name: pulumi.Input[builtins.str] + """ + Target display name + """ + ip: pulumi.Input[builtins.str] + """ + Target IP + """ +elif False: + LoadbalancerTargetPoolTargetArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LoadbalancerTargetPoolTargetArgs: + def __init__(__self__, *, + display_name: pulumi.Input[builtins.str], + ip: pulumi.Input[builtins.str]): + """ + :param pulumi.Input[builtins.str] display_name: Target display name + :param pulumi.Input[builtins.str] ip: Target IP + """ + pulumi.set(__self__, "display_name", display_name) + pulumi.set(__self__, "ip", ip) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> pulumi.Input[builtins.str]: + """ + Target display name + """ + return pulumi.get(self, "display_name") + + @display_name.setter + def display_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "display_name", value) + + @property + @pulumi.getter + def ip(self) -> pulumi.Input[builtins.str]: + """ + Target IP + """ + return pulumi.get(self, "ip") + + @ip.setter + def ip(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "ip", value) + + +if not MYPY: + class LogmeInstanceParametersArgsDict(TypedDict): + enable_monitoring: NotRequired[pulumi.Input[builtins.bool]] + """ + Enable monitoring. + """ + fluentd_tcp: NotRequired[pulumi.Input[builtins.int]] + fluentd_tls: NotRequired[pulumi.Input[builtins.int]] + fluentd_tls_ciphers: NotRequired[pulumi.Input[builtins.str]] + fluentd_tls_max_version: NotRequired[pulumi.Input[builtins.str]] + fluentd_tls_min_version: NotRequired[pulumi.Input[builtins.str]] + fluentd_tls_version: NotRequired[pulumi.Input[builtins.str]] + fluentd_udp: NotRequired[pulumi.Input[builtins.int]] + graphite: NotRequired[pulumi.Input[builtins.str]] + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + ism_deletion_after: NotRequired[pulumi.Input[builtins.str]] + """ + Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + """ + ism_jitter: NotRequired[pulumi.Input[builtins.float]] + ism_job_interval: NotRequired[pulumi.Input[builtins.int]] + """ + Jitter of the execution time. + """ + java_heapspace: NotRequired[pulumi.Input[builtins.int]] + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + java_maxmetaspace: NotRequired[pulumi.Input[builtins.int]] + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + max_disk_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + metrics_frequency: NotRequired[pulumi.Input[builtins.int]] + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + metrics_prefix: NotRequired[pulumi.Input[builtins.str]] + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + monitoring_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the STACKIT monitoring instance. + """ + opensearch_tls_ciphers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + opensearch_tls_protocols: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + sgw_acl: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + syslogs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of syslog servers to send logs to. + """ +elif False: + LogmeInstanceParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class LogmeInstanceParametersArgs: + def __init__(__self__, *, + enable_monitoring: Optional[pulumi.Input[builtins.bool]] = None, + fluentd_tcp: Optional[pulumi.Input[builtins.int]] = None, + fluentd_tls: Optional[pulumi.Input[builtins.int]] = None, + fluentd_tls_ciphers: Optional[pulumi.Input[builtins.str]] = None, + fluentd_tls_max_version: Optional[pulumi.Input[builtins.str]] = None, + fluentd_tls_min_version: Optional[pulumi.Input[builtins.str]] = None, + fluentd_tls_version: Optional[pulumi.Input[builtins.str]] = None, + fluentd_udp: Optional[pulumi.Input[builtins.int]] = None, + graphite: Optional[pulumi.Input[builtins.str]] = None, + ism_deletion_after: Optional[pulumi.Input[builtins.str]] = None, + ism_jitter: Optional[pulumi.Input[builtins.float]] = None, + ism_job_interval: Optional[pulumi.Input[builtins.int]] = None, + java_heapspace: Optional[pulumi.Input[builtins.int]] = None, + java_maxmetaspace: Optional[pulumi.Input[builtins.int]] = None, + max_disk_threshold: Optional[pulumi.Input[builtins.int]] = None, + metrics_frequency: Optional[pulumi.Input[builtins.int]] = None, + metrics_prefix: Optional[pulumi.Input[builtins.str]] = None, + monitoring_instance_id: Optional[pulumi.Input[builtins.str]] = None, + opensearch_tls_ciphers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + opensearch_tls_protocols: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + sgw_acl: Optional[pulumi.Input[builtins.str]] = None, + syslogs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.bool] enable_monitoring: Enable monitoring. + :param pulumi.Input[builtins.str] graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param pulumi.Input[builtins.str] ism_deletion_after: Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + :param pulumi.Input[builtins.int] ism_job_interval: Jitter of the execution time. + :param pulumi.Input[builtins.int] java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param pulumi.Input[builtins.int] java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param pulumi.Input[builtins.int] max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param pulumi.Input[builtins.int] metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param pulumi.Input[builtins.str] metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param pulumi.Input[builtins.str] monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param pulumi.Input[builtins.str] sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] syslogs: List of syslog servers to send logs to. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if fluentd_tcp is not None: + pulumi.set(__self__, "fluentd_tcp", fluentd_tcp) + if fluentd_tls is not None: + pulumi.set(__self__, "fluentd_tls", fluentd_tls) + if fluentd_tls_ciphers is not None: + pulumi.set(__self__, "fluentd_tls_ciphers", fluentd_tls_ciphers) + if fluentd_tls_max_version is not None: + pulumi.set(__self__, "fluentd_tls_max_version", fluentd_tls_max_version) + if fluentd_tls_min_version is not None: + pulumi.set(__self__, "fluentd_tls_min_version", fluentd_tls_min_version) + if fluentd_tls_version is not None: + pulumi.set(__self__, "fluentd_tls_version", fluentd_tls_version) + if fluentd_udp is not None: + pulumi.set(__self__, "fluentd_udp", fluentd_udp) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if ism_deletion_after is not None: + pulumi.set(__self__, "ism_deletion_after", ism_deletion_after) + if ism_jitter is not None: + pulumi.set(__self__, "ism_jitter", ism_jitter) + if ism_job_interval is not None: + pulumi.set(__self__, "ism_job_interval", ism_job_interval) + if java_heapspace is not None: + pulumi.set(__self__, "java_heapspace", java_heapspace) + if java_maxmetaspace is not None: + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if opensearch_tls_ciphers is not None: + pulumi.set(__self__, "opensearch_tls_ciphers", opensearch_tls_ciphers) + if opensearch_tls_protocols is not None: + pulumi.set(__self__, "opensearch_tls_protocols", opensearch_tls_protocols) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @enable_monitoring.setter + def enable_monitoring(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_monitoring", value) + + @property + @pulumi.getter(name="fluentdTcp") + def fluentd_tcp(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "fluentd_tcp") + + @fluentd_tcp.setter + def fluentd_tcp(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "fluentd_tcp", value) + + @property + @pulumi.getter(name="fluentdTls") + def fluentd_tls(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "fluentd_tls") + + @fluentd_tls.setter + def fluentd_tls(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "fluentd_tls", value) + + @property + @pulumi.getter(name="fluentdTlsCiphers") + def fluentd_tls_ciphers(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "fluentd_tls_ciphers") + + @fluentd_tls_ciphers.setter + def fluentd_tls_ciphers(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fluentd_tls_ciphers", value) + + @property + @pulumi.getter(name="fluentdTlsMaxVersion") + def fluentd_tls_max_version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "fluentd_tls_max_version") + + @fluentd_tls_max_version.setter + def fluentd_tls_max_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fluentd_tls_max_version", value) + + @property + @pulumi.getter(name="fluentdTlsMinVersion") + def fluentd_tls_min_version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "fluentd_tls_min_version") + + @fluentd_tls_min_version.setter + def fluentd_tls_min_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fluentd_tls_min_version", value) + + @property + @pulumi.getter(name="fluentdTlsVersion") + def fluentd_tls_version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "fluentd_tls_version") + + @fluentd_tls_version.setter + def fluentd_tls_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fluentd_tls_version", value) + + @property + @pulumi.getter(name="fluentdUdp") + def fluentd_udp(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "fluentd_udp") + + @fluentd_udp.setter + def fluentd_udp(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "fluentd_udp", value) + + @property + @pulumi.getter + def graphite(self) -> Optional[pulumi.Input[builtins.str]]: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @graphite.setter + def graphite(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "graphite", value) + + @property + @pulumi.getter(name="ismDeletionAfter") + def ism_deletion_after(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + """ + return pulumi.get(self, "ism_deletion_after") + + @ism_deletion_after.setter + def ism_deletion_after(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ism_deletion_after", value) + + @property + @pulumi.getter(name="ismJitter") + def ism_jitter(self) -> Optional[pulumi.Input[builtins.float]]: + return pulumi.get(self, "ism_jitter") + + @ism_jitter.setter + def ism_jitter(self, value: Optional[pulumi.Input[builtins.float]]): + pulumi.set(self, "ism_jitter", value) + + @property + @pulumi.getter(name="ismJobInterval") + def ism_job_interval(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Jitter of the execution time. + """ + return pulumi.get(self, "ism_job_interval") + + @ism_job_interval.setter + def ism_job_interval(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ism_job_interval", value) + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @java_heapspace.setter + def java_heapspace(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "java_heapspace", value) + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @java_maxmetaspace.setter + def java_maxmetaspace(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "java_maxmetaspace", value) + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @max_disk_threshold.setter + def max_disk_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_disk_threshold", value) + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @metrics_frequency.setter + def metrics_frequency(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_frequency", value) + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @metrics_prefix.setter + def metrics_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_prefix", value) + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @monitoring_instance_id.setter + def monitoring_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "monitoring_instance_id", value) + + @property + @pulumi.getter(name="opensearchTlsCiphers") + def opensearch_tls_ciphers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "opensearch_tls_ciphers") + + @opensearch_tls_ciphers.setter + def opensearch_tls_ciphers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "opensearch_tls_ciphers", value) + + @property + @pulumi.getter(name="opensearchTlsProtocols") + def opensearch_tls_protocols(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "opensearch_tls_protocols") + + @opensearch_tls_protocols.setter + def opensearch_tls_protocols(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "opensearch_tls_protocols", value) + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @sgw_acl.setter + def sgw_acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sgw_acl", value) + + @property + @pulumi.getter + def syslogs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @syslogs.setter + def syslogs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "syslogs", value) + + +if not MYPY: + class MariadbInstanceParametersArgsDict(TypedDict): + enable_monitoring: NotRequired[pulumi.Input[builtins.bool]] + """ + Enable monitoring. + """ + graphite: NotRequired[pulumi.Input[builtins.str]] + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + max_disk_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + metrics_frequency: NotRequired[pulumi.Input[builtins.int]] + """ + The frequency in seconds at which metrics are emitted. + """ + metrics_prefix: NotRequired[pulumi.Input[builtins.str]] + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + monitoring_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + """ + sgw_acl: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + syslogs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of syslog servers to send logs to. + """ +elif False: + MariadbInstanceParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class MariadbInstanceParametersArgs: + def __init__(__self__, *, + enable_monitoring: Optional[pulumi.Input[builtins.bool]] = None, + graphite: Optional[pulumi.Input[builtins.str]] = None, + max_disk_threshold: Optional[pulumi.Input[builtins.int]] = None, + metrics_frequency: Optional[pulumi.Input[builtins.int]] = None, + metrics_prefix: Optional[pulumi.Input[builtins.str]] = None, + monitoring_instance_id: Optional[pulumi.Input[builtins.str]] = None, + sgw_acl: Optional[pulumi.Input[builtins.str]] = None, + syslogs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.bool] enable_monitoring: Enable monitoring. + :param pulumi.Input[builtins.str] graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param pulumi.Input[builtins.int] max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param pulumi.Input[builtins.int] metrics_frequency: The frequency in seconds at which metrics are emitted. + :param pulumi.Input[builtins.str] metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param pulumi.Input[builtins.str] monitoring_instance_id: The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + :param pulumi.Input[builtins.str] sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] syslogs: List of syslog servers to send logs to. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @enable_monitoring.setter + def enable_monitoring(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_monitoring", value) + + @property + @pulumi.getter + def graphite(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @graphite.setter + def graphite(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "graphite", value) + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @max_disk_threshold.setter + def max_disk_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_disk_threshold", value) + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @metrics_frequency.setter + def metrics_frequency(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_frequency", value) + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @metrics_prefix.setter + def metrics_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_prefix", value) + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + """ + return pulumi.get(self, "monitoring_instance_id") + + @monitoring_instance_id.setter + def monitoring_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "monitoring_instance_id", value) + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @sgw_acl.setter + def sgw_acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sgw_acl", value) + + @property + @pulumi.getter + def syslogs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @syslogs.setter + def syslogs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "syslogs", value) + + +if not MYPY: + class MongodbflexInstanceFlavorArgsDict(TypedDict): + cpu: pulumi.Input[builtins.int] + ram: pulumi.Input[builtins.int] + description: NotRequired[pulumi.Input[builtins.str]] + id: NotRequired[pulumi.Input[builtins.str]] +elif False: + MongodbflexInstanceFlavorArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class MongodbflexInstanceFlavorArgs: + def __init__(__self__, *, + cpu: pulumi.Input[builtins.int], + ram: pulumi.Input[builtins.int], + description: Optional[pulumi.Input[builtins.str]] = None, + id: Optional[pulumi.Input[builtins.str]] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "cpu") + + @cpu.setter + def cpu(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "cpu", value) + + @property + @pulumi.getter + def ram(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "ram") + + @ram.setter + def ram(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "ram", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "id", value) + + +if not MYPY: + class MongodbflexInstanceOptionsArgsDict(TypedDict): + point_in_time_window_hours: pulumi.Input[builtins.int] + """ + The number of hours back in time the point-in-time recovery feature will be able to recover. + """ + type: pulumi.Input[builtins.str] + """ + Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + """ + daily_snapshot_retention_days: NotRequired[pulumi.Input[builtins.int]] + """ + The number of days that daily backups will be retained. + """ + monthly_snapshot_retention_months: NotRequired[pulumi.Input[builtins.int]] + """ + The number of months that monthly backups will be retained. + """ + snapshot_retention_days: NotRequired[pulumi.Input[builtins.int]] + """ + The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + """ + weekly_snapshot_retention_weeks: NotRequired[pulumi.Input[builtins.int]] + """ + The number of weeks that weekly backups will be retained. + """ +elif False: + MongodbflexInstanceOptionsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class MongodbflexInstanceOptionsArgs: + def __init__(__self__, *, + point_in_time_window_hours: pulumi.Input[builtins.int], + type: pulumi.Input[builtins.str], + daily_snapshot_retention_days: Optional[pulumi.Input[builtins.int]] = None, + monthly_snapshot_retention_months: Optional[pulumi.Input[builtins.int]] = None, + snapshot_retention_days: Optional[pulumi.Input[builtins.int]] = None, + weekly_snapshot_retention_weeks: Optional[pulumi.Input[builtins.int]] = None): + """ + :param pulumi.Input[builtins.int] point_in_time_window_hours: The number of hours back in time the point-in-time recovery feature will be able to recover. + :param pulumi.Input[builtins.str] type: Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + :param pulumi.Input[builtins.int] daily_snapshot_retention_days: The number of days that daily backups will be retained. + :param pulumi.Input[builtins.int] monthly_snapshot_retention_months: The number of months that monthly backups will be retained. + :param pulumi.Input[builtins.int] snapshot_retention_days: The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + :param pulumi.Input[builtins.int] weekly_snapshot_retention_weeks: The number of weeks that weekly backups will be retained. + """ + pulumi.set(__self__, "point_in_time_window_hours", point_in_time_window_hours) + pulumi.set(__self__, "type", type) + if daily_snapshot_retention_days is not None: + pulumi.set(__self__, "daily_snapshot_retention_days", daily_snapshot_retention_days) + if monthly_snapshot_retention_months is not None: + pulumi.set(__self__, "monthly_snapshot_retention_months", monthly_snapshot_retention_months) + if snapshot_retention_days is not None: + pulumi.set(__self__, "snapshot_retention_days", snapshot_retention_days) + if weekly_snapshot_retention_weeks is not None: + pulumi.set(__self__, "weekly_snapshot_retention_weeks", weekly_snapshot_retention_weeks) + + @property + @pulumi.getter(name="pointInTimeWindowHours") + def point_in_time_window_hours(self) -> pulumi.Input[builtins.int]: + """ + The number of hours back in time the point-in-time recovery feature will be able to recover. + """ + return pulumi.get(self, "point_in_time_window_hours") + + @point_in_time_window_hours.setter + def point_in_time_window_hours(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "point_in_time_window_hours", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[builtins.str]: + """ + Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="dailySnapshotRetentionDays") + def daily_snapshot_retention_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The number of days that daily backups will be retained. + """ + return pulumi.get(self, "daily_snapshot_retention_days") + + @daily_snapshot_retention_days.setter + def daily_snapshot_retention_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "daily_snapshot_retention_days", value) + + @property + @pulumi.getter(name="monthlySnapshotRetentionMonths") + def monthly_snapshot_retention_months(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The number of months that monthly backups will be retained. + """ + return pulumi.get(self, "monthly_snapshot_retention_months") + + @monthly_snapshot_retention_months.setter + def monthly_snapshot_retention_months(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "monthly_snapshot_retention_months", value) + + @property + @pulumi.getter(name="snapshotRetentionDays") + def snapshot_retention_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + """ + return pulumi.get(self, "snapshot_retention_days") + + @snapshot_retention_days.setter + def snapshot_retention_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "snapshot_retention_days", value) + + @property + @pulumi.getter(name="weeklySnapshotRetentionWeeks") + def weekly_snapshot_retention_weeks(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The number of weeks that weekly backups will be retained. + """ + return pulumi.get(self, "weekly_snapshot_retention_weeks") + + @weekly_snapshot_retention_weeks.setter + def weekly_snapshot_retention_weeks(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "weekly_snapshot_retention_weeks", value) + + +if not MYPY: + class MongodbflexInstanceStorageArgsDict(TypedDict): + class_: pulumi.Input[builtins.str] + size: pulumi.Input[builtins.int] +elif False: + MongodbflexInstanceStorageArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class MongodbflexInstanceStorageArgs: + def __init__(__self__, *, + class_: pulumi.Input[builtins.str], + size: pulumi.Input[builtins.int]): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "class_") + + @class_.setter + def class_(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "class_", value) + + @property + @pulumi.getter + def size(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "size") + + @size.setter + def size(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "size", value) + + +if not MYPY: + class NetworkAreaNetworkRangeArgsDict(TypedDict): + prefix: pulumi.Input[builtins.str] + """ + Classless Inter-Domain Routing (CIDR). + """ + network_range_id: NotRequired[pulumi.Input[builtins.str]] +elif False: + NetworkAreaNetworkRangeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class NetworkAreaNetworkRangeArgs: + def __init__(__self__, *, + prefix: pulumi.Input[builtins.str], + network_range_id: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] prefix: Classless Inter-Domain Routing (CIDR). + """ + pulumi.set(__self__, "prefix", prefix) + if network_range_id is not None: + pulumi.set(__self__, "network_range_id", network_range_id) + + @property + @pulumi.getter + def prefix(self) -> pulumi.Input[builtins.str]: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "prefix") + + @prefix.setter + def prefix(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "prefix", value) + + @property + @pulumi.getter(name="networkRangeId") + def network_range_id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "network_range_id") + + @network_range_id.setter + def network_range_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_range_id", value) + + +if not MYPY: + class ObservabilityAlertgroupRuleArgsDict(TypedDict): + alert: pulumi.Input[builtins.str] + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + expression: pulumi.Input[builtins.str] + """ + The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + for_: NotRequired[pulumi.Input[builtins.str]] + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A map of key:value. Labels to add or overwrite for each alert + """ +elif False: + ObservabilityAlertgroupRuleArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityAlertgroupRuleArgs: + def __init__(__self__, *, + alert: pulumi.Input[builtins.str], + expression: pulumi.Input[builtins.str], + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + for_: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.str] alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] expression: The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param pulumi.Input[builtins.str] for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "expression", expression) + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if for_ is not None: + pulumi.set(__self__, "for_", for_) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> pulumi.Input[builtins.str]: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @alert.setter + def alert(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "alert", value) + + @property + @pulumi.getter + def expression(self) -> pulumi.Input[builtins.str]: + """ + The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @expression.setter + def expression(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "expression", value) + + @property + @pulumi.getter + def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @annotations.setter + def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "annotations", value) + + @property + @pulumi.getter(name="for") + def for_(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @for_.setter + def for_(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "for_", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigArgsDict(TypedDict): + receivers: pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverArgsDict']]] + """ + List of alert receivers. + """ + route: pulumi.Input['ObservabilityInstanceAlertConfigRouteArgsDict'] + """ + Route configuration for the alerts. + """ + global_: NotRequired[pulumi.Input['ObservabilityInstanceAlertConfigGlobalArgsDict']] + """ + Global configuration for the alerts. + """ +elif False: + ObservabilityInstanceAlertConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigArgs: + def __init__(__self__, *, + receivers: pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverArgs']]], + route: pulumi.Input['ObservabilityInstanceAlertConfigRouteArgs'], + global_: Optional[pulumi.Input['ObservabilityInstanceAlertConfigGlobalArgs']] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverArgs']]] receivers: List of alert receivers. + :param pulumi.Input['ObservabilityInstanceAlertConfigRouteArgs'] route: Route configuration for the alerts. + :param pulumi.Input['ObservabilityInstanceAlertConfigGlobalArgs'] global_: Global configuration for the alerts. + """ + pulumi.set(__self__, "receivers", receivers) + pulumi.set(__self__, "route", route) + if global_ is not None: + pulumi.set(__self__, "global_", global_) + + @property + @pulumi.getter + def receivers(self) -> pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverArgs']]]: + """ + List of alert receivers. + """ + return pulumi.get(self, "receivers") + + @receivers.setter + def receivers(self, value: pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverArgs']]]): + pulumi.set(self, "receivers", value) + + @property + @pulumi.getter + def route(self) -> pulumi.Input['ObservabilityInstanceAlertConfigRouteArgs']: + """ + Route configuration for the alerts. + """ + return pulumi.get(self, "route") + + @route.setter + def route(self, value: pulumi.Input['ObservabilityInstanceAlertConfigRouteArgs']): + pulumi.set(self, "route", value) + + @property + @pulumi.getter(name="global") + def global_(self) -> Optional[pulumi.Input['ObservabilityInstanceAlertConfigGlobalArgs']]: + """ + Global configuration for the alerts. + """ + return pulumi.get(self, "global_") + + @global_.setter + def global_(self, value: Optional[pulumi.Input['ObservabilityInstanceAlertConfigGlobalArgs']]): + pulumi.set(self, "global_", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigGlobalArgsDict(TypedDict): + opsgenie_api_key: NotRequired[pulumi.Input[builtins.str]] + """ + The API key for OpsGenie. + """ + opsgenie_api_url: NotRequired[pulumi.Input[builtins.str]] + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + resolve_timeout: NotRequired[pulumi.Input[builtins.str]] + """ + The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + """ + smtp_auth_identity: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP authentication information. Must be a valid email address + """ + smtp_auth_password: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP Auth using LOGIN and PLAIN. + """ + smtp_auth_username: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + """ + smtp_from: NotRequired[pulumi.Input[builtins.str]] + """ + The default SMTP From header field. Must be a valid email address + """ + smtp_smart_host: NotRequired[pulumi.Input[builtins.str]] + """ + The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ +elif False: + ObservabilityInstanceAlertConfigGlobalArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigGlobalArgs: + def __init__(__self__, *, + opsgenie_api_key: Optional[pulumi.Input[builtins.str]] = None, + opsgenie_api_url: Optional[pulumi.Input[builtins.str]] = None, + resolve_timeout: Optional[pulumi.Input[builtins.str]] = None, + smtp_auth_identity: Optional[pulumi.Input[builtins.str]] = None, + smtp_auth_password: Optional[pulumi.Input[builtins.str]] = None, + smtp_auth_username: Optional[pulumi.Input[builtins.str]] = None, + smtp_from: Optional[pulumi.Input[builtins.str]] = None, + smtp_smart_host: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] opsgenie_api_key: The API key for OpsGenie. + :param pulumi.Input[builtins.str] opsgenie_api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param pulumi.Input[builtins.str] resolve_timeout: The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + :param pulumi.Input[builtins.str] smtp_auth_identity: SMTP authentication information. Must be a valid email address + :param pulumi.Input[builtins.str] smtp_auth_password: SMTP Auth using LOGIN and PLAIN. + :param pulumi.Input[builtins.str] smtp_auth_username: SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + :param pulumi.Input[builtins.str] smtp_from: The default SMTP From header field. Must be a valid email address + :param pulumi.Input[builtins.str] smtp_smart_host: The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + if opsgenie_api_key is not None: + pulumi.set(__self__, "opsgenie_api_key", opsgenie_api_key) + if opsgenie_api_url is not None: + pulumi.set(__self__, "opsgenie_api_url", opsgenie_api_url) + if resolve_timeout is not None: + pulumi.set(__self__, "resolve_timeout", resolve_timeout) + if smtp_auth_identity is not None: + pulumi.set(__self__, "smtp_auth_identity", smtp_auth_identity) + if smtp_auth_password is not None: + pulumi.set(__self__, "smtp_auth_password", smtp_auth_password) + if smtp_auth_username is not None: + pulumi.set(__self__, "smtp_auth_username", smtp_auth_username) + if smtp_from is not None: + pulumi.set(__self__, "smtp_from", smtp_from) + if smtp_smart_host is not None: + pulumi.set(__self__, "smtp_smart_host", smtp_smart_host) + + @property + @pulumi.getter(name="opsgenieApiKey") + def opsgenie_api_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "opsgenie_api_key") + + @opsgenie_api_key.setter + def opsgenie_api_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "opsgenie_api_key", value) + + @property + @pulumi.getter(name="opsgenieApiUrl") + def opsgenie_api_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "opsgenie_api_url") + + @opsgenie_api_url.setter + def opsgenie_api_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "opsgenie_api_url", value) + + @property + @pulumi.getter(name="resolveTimeout") + def resolve_timeout(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + """ + return pulumi.get(self, "resolve_timeout") + + @resolve_timeout.setter + def resolve_timeout(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "resolve_timeout", value) + + @property + @pulumi.getter(name="smtpAuthIdentity") + def smtp_auth_identity(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "smtp_auth_identity") + + @smtp_auth_identity.setter + def smtp_auth_identity(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smtp_auth_identity", value) + + @property + @pulumi.getter(name="smtpAuthPassword") + def smtp_auth_password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP Auth using LOGIN and PLAIN. + """ + return pulumi.get(self, "smtp_auth_password") + + @smtp_auth_password.setter + def smtp_auth_password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smtp_auth_password", value) + + @property + @pulumi.getter(name="smtpAuthUsername") + def smtp_auth_username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + """ + return pulumi.get(self, "smtp_auth_username") + + @smtp_auth_username.setter + def smtp_auth_username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smtp_auth_username", value) + + @property + @pulumi.getter(name="smtpFrom") + def smtp_from(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The default SMTP From header field. Must be a valid email address + """ + return pulumi.get(self, "smtp_from") + + @smtp_from.setter + def smtp_from(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smtp_from", value) + + @property + @pulumi.getter(name="smtpSmartHost") + def smtp_smart_host(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + return pulumi.get(self, "smtp_smart_host") + + @smtp_smart_host.setter + def smtp_smart_host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smtp_smart_host", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigReceiverArgsDict(TypedDict): + name: pulumi.Input[builtins.str] + """ + Name of the receiver. + """ + email_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverEmailConfigArgsDict']]]] + """ + List of email configurations. + """ + opsgenie_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgsDict']]]] + """ + List of OpsGenie configurations. + """ + webhooks_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgsDict']]]] + """ + List of Webhooks configurations. + """ +elif False: + ObservabilityInstanceAlertConfigReceiverArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigReceiverArgs: + def __init__(__self__, *, + name: pulumi.Input[builtins.str], + email_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverEmailConfigArgs']]]] = None, + opsgenie_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs']]]] = None, + webhooks_configs: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs']]]] = None): + """ + :param pulumi.Input[builtins.str] name: Name of the receiver. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverEmailConfigArgs']]] email_configs: List of email configurations. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs']]] opsgenie_configs: List of OpsGenie configurations. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs']]] webhooks_configs: List of Webhooks configurations. + """ + pulumi.set(__self__, "name", name) + if email_configs is not None: + pulumi.set(__self__, "email_configs", email_configs) + if opsgenie_configs is not None: + pulumi.set(__self__, "opsgenie_configs", opsgenie_configs) + if webhooks_configs is not None: + pulumi.set(__self__, "webhooks_configs", webhooks_configs) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[builtins.str]: + """ + Name of the receiver. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="emailConfigs") + def email_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverEmailConfigArgs']]]]: + """ + List of email configurations. + """ + return pulumi.get(self, "email_configs") + + @email_configs.setter + def email_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverEmailConfigArgs']]]]): + pulumi.set(self, "email_configs", value) + + @property + @pulumi.getter(name="opsgenieConfigs") + def opsgenie_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs']]]]: + """ + List of OpsGenie configurations. + """ + return pulumi.get(self, "opsgenie_configs") + + @opsgenie_configs.setter + def opsgenie_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs']]]]): + pulumi.set(self, "opsgenie_configs", value) + + @property + @pulumi.getter(name="webhooksConfigs") + def webhooks_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs']]]]: + """ + List of Webhooks configurations. + """ + return pulumi.get(self, "webhooks_configs") + + @webhooks_configs.setter + def webhooks_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs']]]]): + pulumi.set(self, "webhooks_configs", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigReceiverEmailConfigArgsDict(TypedDict): + auth_identity: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP authentication information. Must be a valid email address + """ + auth_password: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP authentication password. + """ + auth_username: NotRequired[pulumi.Input[builtins.str]] + """ + SMTP authentication username. + """ + from_: NotRequired[pulumi.Input[builtins.str]] + """ + The sender email address. Must be a valid email address + """ + smart_host: NotRequired[pulumi.Input[builtins.str]] + """ + The SMTP host through which emails are sent. + """ + to: NotRequired[pulumi.Input[builtins.str]] + """ + The email address to send notifications to. Must be a valid email address + """ +elif False: + ObservabilityInstanceAlertConfigReceiverEmailConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigReceiverEmailConfigArgs: + def __init__(__self__, *, + auth_identity: Optional[pulumi.Input[builtins.str]] = None, + auth_password: Optional[pulumi.Input[builtins.str]] = None, + auth_username: Optional[pulumi.Input[builtins.str]] = None, + from_: Optional[pulumi.Input[builtins.str]] = None, + smart_host: Optional[pulumi.Input[builtins.str]] = None, + to: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] auth_identity: SMTP authentication information. Must be a valid email address + :param pulumi.Input[builtins.str] auth_password: SMTP authentication password. + :param pulumi.Input[builtins.str] auth_username: SMTP authentication username. + :param pulumi.Input[builtins.str] from_: The sender email address. Must be a valid email address + :param pulumi.Input[builtins.str] smart_host: The SMTP host through which emails are sent. + :param pulumi.Input[builtins.str] to: The email address to send notifications to. Must be a valid email address + """ + if auth_identity is not None: + pulumi.set(__self__, "auth_identity", auth_identity) + if auth_password is not None: + pulumi.set(__self__, "auth_password", auth_password) + if auth_username is not None: + pulumi.set(__self__, "auth_username", auth_username) + if from_ is not None: + pulumi.set(__self__, "from_", from_) + if smart_host is not None: + pulumi.set(__self__, "smart_host", smart_host) + if to is not None: + pulumi.set(__self__, "to", to) + + @property + @pulumi.getter(name="authIdentity") + def auth_identity(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "auth_identity") + + @auth_identity.setter + def auth_identity(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "auth_identity", value) + + @property + @pulumi.getter(name="authPassword") + def auth_password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP authentication password. + """ + return pulumi.get(self, "auth_password") + + @auth_password.setter + def auth_password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "auth_password", value) + + @property + @pulumi.getter(name="authUsername") + def auth_username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + SMTP authentication username. + """ + return pulumi.get(self, "auth_username") + + @auth_username.setter + def auth_username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "auth_username", value) + + @property + @pulumi.getter(name="from") + def from_(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The sender email address. Must be a valid email address + """ + return pulumi.get(self, "from_") + + @from_.setter + def from_(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "from_", value) + + @property + @pulumi.getter(name="smartHost") + def smart_host(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The SMTP host through which emails are sent. + """ + return pulumi.get(self, "smart_host") + + @smart_host.setter + def smart_host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "smart_host", value) + + @property + @pulumi.getter + def to(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The email address to send notifications to. Must be a valid email address + """ + return pulumi.get(self, "to") + + @to.setter + def to(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "to", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgsDict(TypedDict): + api_key: NotRequired[pulumi.Input[builtins.str]] + """ + The API key for OpsGenie. + """ + api_url: NotRequired[pulumi.Input[builtins.str]] + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + tags: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of tags attached to the notifications. + """ +elif False: + ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs: + def __init__(__self__, *, + api_key: Optional[pulumi.Input[builtins.str]] = None, + api_url: Optional[pulumi.Input[builtins.str]] = None, + tags: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] api_key: The API key for OpsGenie. + :param pulumi.Input[builtins.str] api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param pulumi.Input[builtins.str] tags: Comma separated list of tags attached to the notifications. + """ + if api_key is not None: + pulumi.set(__self__, "api_key", api_key) + if api_url is not None: + pulumi.set(__self__, "api_url", api_url) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "api_key") + + @api_key.setter + def api_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "api_key", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of tags attached to the notifications. + """ + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "tags", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgsDict(TypedDict): + ms_teams: NotRequired[pulumi.Input[builtins.bool]] + """ + Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + """ + url: NotRequired[pulumi.Input[builtins.str]] + """ + The endpoint to send HTTP POST requests to. Must be a valid URL + """ +elif False: + ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs: + def __init__(__self__, *, + ms_teams: Optional[pulumi.Input[builtins.bool]] = None, + url: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.bool] ms_teams: Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + :param pulumi.Input[builtins.str] url: The endpoint to send HTTP POST requests to. Must be a valid URL + """ + if ms_teams is not None: + pulumi.set(__self__, "ms_teams", ms_teams) + if url is not None: + pulumi.set(__self__, "url", url) + + @property + @pulumi.getter(name="msTeams") + def ms_teams(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + """ + return pulumi.get(self, "ms_teams") + + @ms_teams.setter + def ms_teams(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "ms_teams", value) + + @property + @pulumi.getter + def url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The endpoint to send HTTP POST requests to. Must be a valid URL + """ + return pulumi.get(self, "url") + + @url.setter + def url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "url", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigRouteArgsDict(TypedDict): + receiver: pulumi.Input[builtins.str] + """ + The name of the receiver to route the alerts to. + """ + group_bies: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + group_interval: NotRequired[pulumi.Input[builtins.str]] + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + group_wait: NotRequired[pulumi.Input[builtins.str]] + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + match: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + match_regex: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + repeat_interval: NotRequired[pulumi.Input[builtins.str]] + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigRouteRouteArgsDict']]]] + """ + List of child routes. + """ +elif False: + ObservabilityInstanceAlertConfigRouteArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigRouteArgs: + def __init__(__self__, *, + receiver: pulumi.Input[builtins.str], + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + group_interval: Optional[pulumi.Input[builtins.str]] = None, + group_wait: Optional[pulumi.Input[builtins.str]] = None, + match: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + match_regex: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + repeat_interval: Optional[pulumi.Input[builtins.str]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigRouteRouteArgs']]]] = None): + """ + :param pulumi.Input[builtins.str] receiver: The name of the receiver to route the alerts to. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param pulumi.Input[builtins.str] group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param pulumi.Input[builtins.str] group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] match: A set of equality matchers an alert has to fulfill to match the node. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param pulumi.Input[builtins.str] repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigRouteRouteArgs']]] routes: List of child routes. + """ + pulumi.set(__self__, "receiver", receiver) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if group_interval is not None: + pulumi.set(__self__, "group_interval", group_interval) + if group_wait is not None: + pulumi.set(__self__, "group_wait", group_wait) + if match is not None: + pulumi.set(__self__, "match", match) + if match_regex is not None: + pulumi.set(__self__, "match_regex", match_regex) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter + def receiver(self) -> pulumi.Input[builtins.str]: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @receiver.setter + def receiver(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "receiver", value) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @group_interval.setter + def group_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "group_interval", value) + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + return pulumi.get(self, "group_wait") + + @group_wait.setter + def group_wait(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "group_wait", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "match", value) + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @match_regex.setter + def match_regex(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "match_regex", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "repeat_interval", value) + + @property + @pulumi.getter + def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigRouteRouteArgs']]]]: + """ + List of child routes. + """ + return pulumi.get(self, "routes") + + @routes.setter + def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityInstanceAlertConfigRouteRouteArgs']]]]): + pulumi.set(self, "routes", value) + + +if not MYPY: + class ObservabilityInstanceAlertConfigRouteRouteArgsDict(TypedDict): + receiver: pulumi.Input[builtins.str] + """ + The name of the receiver to route the alerts to. + """ + group_bies: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + group_interval: NotRequired[pulumi.Input[builtins.str]] + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + group_wait: NotRequired[pulumi.Input[builtins.str]] + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + match: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + match_regex: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + repeat_interval: NotRequired[pulumi.Input[builtins.str]] + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ +elif False: + ObservabilityInstanceAlertConfigRouteRouteArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityInstanceAlertConfigRouteRouteArgs: + def __init__(__self__, *, + receiver: pulumi.Input[builtins.str], + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + group_interval: Optional[pulumi.Input[builtins.str]] = None, + group_wait: Optional[pulumi.Input[builtins.str]] = None, + match: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + match_regex: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + repeat_interval: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] receiver: The name of the receiver to route the alerts to. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param pulumi.Input[builtins.str] group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param pulumi.Input[builtins.str] group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] match: A set of equality matchers an alert has to fulfill to match the node. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param pulumi.Input[builtins.str] repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + pulumi.set(__self__, "receiver", receiver) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if group_interval is not None: + pulumi.set(__self__, "group_interval", group_interval) + if group_wait is not None: + pulumi.set(__self__, "group_wait", group_wait) + if match is not None: + pulumi.set(__self__, "match", match) + if match_regex is not None: + pulumi.set(__self__, "match_regex", match_regex) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def receiver(self) -> pulumi.Input[builtins.str]: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @receiver.setter + def receiver(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "receiver", value) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @group_interval.setter + def group_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "group_interval", value) + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + return pulumi.get(self, "group_wait") + + @group_wait.setter + def group_wait(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "group_wait", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "match", value) + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @match_regex.setter + def match_regex(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "match_regex", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "repeat_interval", value) + + +if not MYPY: + class ObservabilityLogalertgroupRuleArgsDict(TypedDict): + alert: pulumi.Input[builtins.str] + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + expression: pulumi.Input[builtins.str] + """ + The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + annotations: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + for_: NotRequired[pulumi.Input[builtins.str]] + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + A map of key:value. Labels to add or overwrite for each alert + """ +elif False: + ObservabilityLogalertgroupRuleArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityLogalertgroupRuleArgs: + def __init__(__self__, *, + alert: pulumi.Input[builtins.str], + expression: pulumi.Input[builtins.str], + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + for_: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.str] alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] expression: The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param pulumi.Input[builtins.str] for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "expression", expression) + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if for_ is not None: + pulumi.set(__self__, "for_", for_) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> pulumi.Input[builtins.str]: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @alert.setter + def alert(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "alert", value) + + @property + @pulumi.getter + def expression(self) -> pulumi.Input[builtins.str]: + """ + The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @expression.setter + def expression(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "expression", value) + + @property + @pulumi.getter + def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @annotations.setter + def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "annotations", value) + + @property + @pulumi.getter(name="for") + def for_(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @for_.setter + def for_(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "for_", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + +if not MYPY: + class ObservabilityScrapeconfigBasicAuthArgsDict(TypedDict): + password: pulumi.Input[builtins.str] + """ + Specifies basic auth password. + """ + username: pulumi.Input[builtins.str] + """ + Specifies basic auth username. + """ +elif False: + ObservabilityScrapeconfigBasicAuthArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityScrapeconfigBasicAuthArgs: + def __init__(__self__, *, + password: pulumi.Input[builtins.str], + username: pulumi.Input[builtins.str]): + """ + :param pulumi.Input[builtins.str] password: Specifies basic auth password. + :param pulumi.Input[builtins.str] username: Specifies basic auth username. + """ + pulumi.set(__self__, "password", password) + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def password(self) -> pulumi.Input[builtins.str]: + """ + Specifies basic auth password. + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def username(self) -> pulumi.Input[builtins.str]: + """ + Specifies basic auth username. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "username", value) + + +if not MYPY: + class ObservabilityScrapeconfigSaml2ArgsDict(TypedDict): + enable_url_parameters: NotRequired[pulumi.Input[builtins.bool]] + """ + Specifies if URL parameters are enabled. Defaults to `true` + """ +elif False: + ObservabilityScrapeconfigSaml2ArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityScrapeconfigSaml2Args: + def __init__(__self__, *, + enable_url_parameters: Optional[pulumi.Input[builtins.bool]] = None): + """ + :param pulumi.Input[builtins.bool] enable_url_parameters: Specifies if URL parameters are enabled. Defaults to `true` + """ + if enable_url_parameters is not None: + pulumi.set(__self__, "enable_url_parameters", enable_url_parameters) + + @property + @pulumi.getter(name="enableUrlParameters") + def enable_url_parameters(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies if URL parameters are enabled. Defaults to `true` + """ + return pulumi.get(self, "enable_url_parameters") + + @enable_url_parameters.setter + def enable_url_parameters(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_url_parameters", value) + + +if not MYPY: + class ObservabilityScrapeconfigTargetArgsDict(TypedDict): + urls: pulumi.Input[Sequence[pulumi.Input[builtins.str]]] + """ + Specifies target URLs. + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + Specifies labels. + """ +elif False: + ObservabilityScrapeconfigTargetArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ObservabilityScrapeconfigTargetArgs: + def __init__(__self__, *, + urls: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] urls: Specifies target URLs. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Specifies labels. + """ + pulumi.set(__self__, "urls", urls) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def urls(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Specifies target URLs. + """ + return pulumi.get(self, "urls") + + @urls.setter + def urls(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "urls", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Specifies labels. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + +if not MYPY: + class OpensearchInstanceParametersArgsDict(TypedDict): + enable_monitoring: NotRequired[pulumi.Input[builtins.bool]] + """ + Enable monitoring. + """ + graphite: NotRequired[pulumi.Input[builtins.str]] + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + java_garbage_collector: NotRequired[pulumi.Input[builtins.str]] + """ + The garbage collector to use for OpenSearch. + """ + java_heapspace: NotRequired[pulumi.Input[builtins.int]] + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + java_maxmetaspace: NotRequired[pulumi.Input[builtins.int]] + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + max_disk_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + metrics_frequency: NotRequired[pulumi.Input[builtins.int]] + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + metrics_prefix: NotRequired[pulumi.Input[builtins.str]] + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + monitoring_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the STACKIT monitoring instance. + """ + plugins: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + """ + sgw_acl: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + syslogs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of syslog servers to send logs to. + """ + tls_ciphers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of TLS ciphers to use. + """ + tls_protocols: NotRequired[pulumi.Input[builtins.str]] + """ + The TLS protocol to use. + """ +elif False: + OpensearchInstanceParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class OpensearchInstanceParametersArgs: + def __init__(__self__, *, + enable_monitoring: Optional[pulumi.Input[builtins.bool]] = None, + graphite: Optional[pulumi.Input[builtins.str]] = None, + java_garbage_collector: Optional[pulumi.Input[builtins.str]] = None, + java_heapspace: Optional[pulumi.Input[builtins.int]] = None, + java_maxmetaspace: Optional[pulumi.Input[builtins.int]] = None, + max_disk_threshold: Optional[pulumi.Input[builtins.int]] = None, + metrics_frequency: Optional[pulumi.Input[builtins.int]] = None, + metrics_prefix: Optional[pulumi.Input[builtins.str]] = None, + monitoring_instance_id: Optional[pulumi.Input[builtins.str]] = None, + plugins: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + sgw_acl: Optional[pulumi.Input[builtins.str]] = None, + syslogs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_ciphers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_protocols: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.bool] enable_monitoring: Enable monitoring. + :param pulumi.Input[builtins.str] graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param pulumi.Input[builtins.str] java_garbage_collector: The garbage collector to use for OpenSearch. + :param pulumi.Input[builtins.int] java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param pulumi.Input[builtins.int] java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param pulumi.Input[builtins.int] max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param pulumi.Input[builtins.int] metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param pulumi.Input[builtins.str] metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param pulumi.Input[builtins.str] monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] plugins: List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + :param pulumi.Input[builtins.str] sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] syslogs: List of syslog servers to send logs to. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] tls_ciphers: List of TLS ciphers to use. + :param pulumi.Input[builtins.str] tls_protocols: The TLS protocol to use. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if java_garbage_collector is not None: + pulumi.set(__self__, "java_garbage_collector", java_garbage_collector) + if java_heapspace is not None: + pulumi.set(__self__, "java_heapspace", java_heapspace) + if java_maxmetaspace is not None: + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if plugins is not None: + pulumi.set(__self__, "plugins", plugins) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @enable_monitoring.setter + def enable_monitoring(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_monitoring", value) + + @property + @pulumi.getter + def graphite(self) -> Optional[pulumi.Input[builtins.str]]: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @graphite.setter + def graphite(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "graphite", value) + + @property + @pulumi.getter(name="javaGarbageCollector") + def java_garbage_collector(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The garbage collector to use for OpenSearch. + """ + return pulumi.get(self, "java_garbage_collector") + + @java_garbage_collector.setter + def java_garbage_collector(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "java_garbage_collector", value) + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @java_heapspace.setter + def java_heapspace(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "java_heapspace", value) + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @java_maxmetaspace.setter + def java_maxmetaspace(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "java_maxmetaspace", value) + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @max_disk_threshold.setter + def max_disk_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_disk_threshold", value) + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @metrics_frequency.setter + def metrics_frequency(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_frequency", value) + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @metrics_prefix.setter + def metrics_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_prefix", value) + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @monitoring_instance_id.setter + def monitoring_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "monitoring_instance_id", value) + + @property + @pulumi.getter + def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + """ + return pulumi.get(self, "plugins") + + @plugins.setter + def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "plugins", value) + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @sgw_acl.setter + def sgw_acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sgw_acl", value) + + @property + @pulumi.getter + def syslogs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @syslogs.setter + def syslogs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "syslogs", value) + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @tls_ciphers.setter + def tls_ciphers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "tls_ciphers", value) + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + @tls_protocols.setter + def tls_protocols(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "tls_protocols", value) + + +if not MYPY: + class PostgresflexInstanceFlavorArgsDict(TypedDict): + cpu: pulumi.Input[builtins.int] + ram: pulumi.Input[builtins.int] + description: NotRequired[pulumi.Input[builtins.str]] + id: NotRequired[pulumi.Input[builtins.str]] +elif False: + PostgresflexInstanceFlavorArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PostgresflexInstanceFlavorArgs: + def __init__(__self__, *, + cpu: pulumi.Input[builtins.int], + ram: pulumi.Input[builtins.int], + description: Optional[pulumi.Input[builtins.str]] = None, + id: Optional[pulumi.Input[builtins.str]] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "cpu") + + @cpu.setter + def cpu(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "cpu", value) + + @property + @pulumi.getter + def ram(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "ram") + + @ram.setter + def ram(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "ram", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "id", value) + + +if not MYPY: + class PostgresflexInstanceStorageArgsDict(TypedDict): + class_: pulumi.Input[builtins.str] + size: pulumi.Input[builtins.int] +elif False: + PostgresflexInstanceStorageArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class PostgresflexInstanceStorageArgs: + def __init__(__self__, *, + class_: pulumi.Input[builtins.str], + size: pulumi.Input[builtins.int]): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "class_") + + @class_.setter + def class_(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "class_", value) + + @property + @pulumi.getter + def size(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "size") + + @size.setter + def size(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "size", value) + + +if not MYPY: + class RabbitmqInstanceParametersArgsDict(TypedDict): + consumer_timeout: NotRequired[pulumi.Input[builtins.int]] + """ + The timeout in milliseconds for the consumer. + """ + enable_monitoring: NotRequired[pulumi.Input[builtins.bool]] + """ + Enable monitoring. + """ + graphite: NotRequired[pulumi.Input[builtins.str]] + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + max_disk_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + metrics_frequency: NotRequired[pulumi.Input[builtins.int]] + """ + The frequency in seconds at which metrics are emitted. + """ + metrics_prefix: NotRequired[pulumi.Input[builtins.str]] + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + monitoring_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the STACKIT monitoring instance. + """ + plugins: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of plugins to install. Must be a supported plugin name. + """ + roles: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of roles to assign to the instance. + """ + sgw_acl: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + syslogs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of syslog servers to send logs to. + """ + tls_ciphers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of TLS ciphers to use. + """ + tls_protocols: NotRequired[pulumi.Input[builtins.str]] + """ + TLS protocol to use. + """ +elif False: + RabbitmqInstanceParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class RabbitmqInstanceParametersArgs: + def __init__(__self__, *, + consumer_timeout: Optional[pulumi.Input[builtins.int]] = None, + enable_monitoring: Optional[pulumi.Input[builtins.bool]] = None, + graphite: Optional[pulumi.Input[builtins.str]] = None, + max_disk_threshold: Optional[pulumi.Input[builtins.int]] = None, + metrics_frequency: Optional[pulumi.Input[builtins.int]] = None, + metrics_prefix: Optional[pulumi.Input[builtins.str]] = None, + monitoring_instance_id: Optional[pulumi.Input[builtins.str]] = None, + plugins: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + sgw_acl: Optional[pulumi.Input[builtins.str]] = None, + syslogs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_ciphers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_protocols: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.int] consumer_timeout: The timeout in milliseconds for the consumer. + :param pulumi.Input[builtins.bool] enable_monitoring: Enable monitoring. + :param pulumi.Input[builtins.str] graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param pulumi.Input[builtins.int] max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param pulumi.Input[builtins.int] metrics_frequency: The frequency in seconds at which metrics are emitted. + :param pulumi.Input[builtins.str] metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param pulumi.Input[builtins.str] monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] plugins: List of plugins to install. Must be a supported plugin name. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: List of roles to assign to the instance. + :param pulumi.Input[builtins.str] sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] syslogs: List of syslog servers to send logs to. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] tls_ciphers: List of TLS ciphers to use. + :param pulumi.Input[builtins.str] tls_protocols: TLS protocol to use. + """ + if consumer_timeout is not None: + pulumi.set(__self__, "consumer_timeout", consumer_timeout) + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if plugins is not None: + pulumi.set(__self__, "plugins", plugins) + if roles is not None: + pulumi.set(__self__, "roles", roles) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="consumerTimeout") + def consumer_timeout(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The timeout in milliseconds for the consumer. + """ + return pulumi.get(self, "consumer_timeout") + + @consumer_timeout.setter + def consumer_timeout(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "consumer_timeout", value) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @enable_monitoring.setter + def enable_monitoring(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_monitoring", value) + + @property + @pulumi.getter + def graphite(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @graphite.setter + def graphite(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "graphite", value) + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @max_disk_threshold.setter + def max_disk_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_disk_threshold", value) + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @metrics_frequency.setter + def metrics_frequency(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_frequency", value) + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @metrics_prefix.setter + def metrics_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_prefix", value) + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @monitoring_instance_id.setter + def monitoring_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "monitoring_instance_id", value) + + @property + @pulumi.getter + def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of plugins to install. Must be a supported plugin name. + """ + return pulumi.get(self, "plugins") + + @plugins.setter + def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "plugins", value) + + @property + @pulumi.getter + def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of roles to assign to the instance. + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @sgw_acl.setter + def sgw_acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sgw_acl", value) + + @property + @pulumi.getter + def syslogs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @syslogs.setter + def syslogs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "syslogs", value) + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @tls_ciphers.setter + def tls_ciphers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "tls_ciphers", value) + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[pulumi.Input[builtins.str]]: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + @tls_protocols.setter + def tls_protocols(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "tls_protocols", value) + + +if not MYPY: + class RedisInstanceParametersArgsDict(TypedDict): + down_after_milliseconds: NotRequired[pulumi.Input[builtins.int]] + """ + The number of milliseconds after which the instance is considered down. + """ + enable_monitoring: NotRequired[pulumi.Input[builtins.bool]] + """ + Enable monitoring. + """ + failover_timeout: NotRequired[pulumi.Input[builtins.int]] + """ + The failover timeout in milliseconds. + """ + graphite: NotRequired[pulumi.Input[builtins.str]] + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + lazyfree_lazy_eviction: NotRequired[pulumi.Input[builtins.str]] + """ + The lazy eviction enablement (yes or no). + """ + lazyfree_lazy_expire: NotRequired[pulumi.Input[builtins.str]] + """ + The lazy expire enablement (yes or no). + """ + lua_time_limit: NotRequired[pulumi.Input[builtins.int]] + """ + The Lua time limit. + """ + max_disk_threshold: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + maxclients: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum number of clients. + """ + maxmemory_policy: NotRequired[pulumi.Input[builtins.str]] + """ + The policy to handle the maximum memory (volatile-lru, noeviction, etc). + """ + maxmemory_samples: NotRequired[pulumi.Input[builtins.int]] + """ + The maximum memory samples. + """ + metrics_frequency: NotRequired[pulumi.Input[builtins.int]] + """ + The frequency in seconds at which metrics are emitted. + """ + metrics_prefix: NotRequired[pulumi.Input[builtins.str]] + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + min_replicas_max_lag: NotRequired[pulumi.Input[builtins.int]] + """ + The minimum replicas maximum lag. + """ + monitoring_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the STACKIT monitoring instance. + """ + notify_keyspace_events: NotRequired[pulumi.Input[builtins.str]] + """ + The notify keyspace events. + """ + sgw_acl: NotRequired[pulumi.Input[builtins.str]] + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + snapshot: NotRequired[pulumi.Input[builtins.str]] + """ + The snapshot configuration. + """ + syslogs: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of syslog servers to send logs to. + """ + tls_ciphers: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + List of TLS ciphers to use. + """ + tls_ciphersuites: NotRequired[pulumi.Input[builtins.str]] + """ + TLS cipher suites to use. + """ + tls_protocols: NotRequired[pulumi.Input[builtins.str]] + """ + TLS protocol to use. + """ +elif False: + RedisInstanceParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class RedisInstanceParametersArgs: + def __init__(__self__, *, + down_after_milliseconds: Optional[pulumi.Input[builtins.int]] = None, + enable_monitoring: Optional[pulumi.Input[builtins.bool]] = None, + failover_timeout: Optional[pulumi.Input[builtins.int]] = None, + graphite: Optional[pulumi.Input[builtins.str]] = None, + lazyfree_lazy_eviction: Optional[pulumi.Input[builtins.str]] = None, + lazyfree_lazy_expire: Optional[pulumi.Input[builtins.str]] = None, + lua_time_limit: Optional[pulumi.Input[builtins.int]] = None, + max_disk_threshold: Optional[pulumi.Input[builtins.int]] = None, + maxclients: Optional[pulumi.Input[builtins.int]] = None, + maxmemory_policy: Optional[pulumi.Input[builtins.str]] = None, + maxmemory_samples: Optional[pulumi.Input[builtins.int]] = None, + metrics_frequency: Optional[pulumi.Input[builtins.int]] = None, + metrics_prefix: Optional[pulumi.Input[builtins.str]] = None, + min_replicas_max_lag: Optional[pulumi.Input[builtins.int]] = None, + monitoring_instance_id: Optional[pulumi.Input[builtins.str]] = None, + notify_keyspace_events: Optional[pulumi.Input[builtins.str]] = None, + sgw_acl: Optional[pulumi.Input[builtins.str]] = None, + snapshot: Optional[pulumi.Input[builtins.str]] = None, + syslogs: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_ciphers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + tls_ciphersuites: Optional[pulumi.Input[builtins.str]] = None, + tls_protocols: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.int] down_after_milliseconds: The number of milliseconds after which the instance is considered down. + :param pulumi.Input[builtins.bool] enable_monitoring: Enable monitoring. + :param pulumi.Input[builtins.int] failover_timeout: The failover timeout in milliseconds. + :param pulumi.Input[builtins.str] graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param pulumi.Input[builtins.str] lazyfree_lazy_eviction: The lazy eviction enablement (yes or no). + :param pulumi.Input[builtins.str] lazyfree_lazy_expire: The lazy expire enablement (yes or no). + :param pulumi.Input[builtins.int] lua_time_limit: The Lua time limit. + :param pulumi.Input[builtins.int] max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param pulumi.Input[builtins.int] maxclients: The maximum number of clients. + :param pulumi.Input[builtins.str] maxmemory_policy: The policy to handle the maximum memory (volatile-lru, noeviction, etc). + :param pulumi.Input[builtins.int] maxmemory_samples: The maximum memory samples. + :param pulumi.Input[builtins.int] metrics_frequency: The frequency in seconds at which metrics are emitted. + :param pulumi.Input[builtins.str] metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param pulumi.Input[builtins.int] min_replicas_max_lag: The minimum replicas maximum lag. + :param pulumi.Input[builtins.str] monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param pulumi.Input[builtins.str] notify_keyspace_events: The notify keyspace events. + :param pulumi.Input[builtins.str] sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param pulumi.Input[builtins.str] snapshot: The snapshot configuration. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] syslogs: List of syslog servers to send logs to. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] tls_ciphers: List of TLS ciphers to use. + :param pulumi.Input[builtins.str] tls_ciphersuites: TLS cipher suites to use. + :param pulumi.Input[builtins.str] tls_protocols: TLS protocol to use. + """ + if down_after_milliseconds is not None: + pulumi.set(__self__, "down_after_milliseconds", down_after_milliseconds) + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if failover_timeout is not None: + pulumi.set(__self__, "failover_timeout", failover_timeout) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if lazyfree_lazy_eviction is not None: + pulumi.set(__self__, "lazyfree_lazy_eviction", lazyfree_lazy_eviction) + if lazyfree_lazy_expire is not None: + pulumi.set(__self__, "lazyfree_lazy_expire", lazyfree_lazy_expire) + if lua_time_limit is not None: + pulumi.set(__self__, "lua_time_limit", lua_time_limit) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if maxclients is not None: + pulumi.set(__self__, "maxclients", maxclients) + if maxmemory_policy is not None: + pulumi.set(__self__, "maxmemory_policy", maxmemory_policy) + if maxmemory_samples is not None: + pulumi.set(__self__, "maxmemory_samples", maxmemory_samples) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if min_replicas_max_lag is not None: + pulumi.set(__self__, "min_replicas_max_lag", min_replicas_max_lag) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if notify_keyspace_events is not None: + pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if snapshot is not None: + pulumi.set(__self__, "snapshot", snapshot) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_ciphersuites is not None: + pulumi.set(__self__, "tls_ciphersuites", tls_ciphersuites) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="downAfterMilliseconds") + def down_after_milliseconds(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The number of milliseconds after which the instance is considered down. + """ + return pulumi.get(self, "down_after_milliseconds") + + @down_after_milliseconds.setter + def down_after_milliseconds(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "down_after_milliseconds", value) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @enable_monitoring.setter + def enable_monitoring(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_monitoring", value) + + @property + @pulumi.getter(name="failoverTimeout") + def failover_timeout(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The failover timeout in milliseconds. + """ + return pulumi.get(self, "failover_timeout") + + @failover_timeout.setter + def failover_timeout(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "failover_timeout", value) + + @property + @pulumi.getter + def graphite(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @graphite.setter + def graphite(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "graphite", value) + + @property + @pulumi.getter(name="lazyfreeLazyEviction") + def lazyfree_lazy_eviction(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The lazy eviction enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_eviction") + + @lazyfree_lazy_eviction.setter + def lazyfree_lazy_eviction(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "lazyfree_lazy_eviction", value) + + @property + @pulumi.getter(name="lazyfreeLazyExpire") + def lazyfree_lazy_expire(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The lazy expire enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_expire") + + @lazyfree_lazy_expire.setter + def lazyfree_lazy_expire(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "lazyfree_lazy_expire", value) + + @property + @pulumi.getter(name="luaTimeLimit") + def lua_time_limit(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The Lua time limit. + """ + return pulumi.get(self, "lua_time_limit") + + @lua_time_limit.setter + def lua_time_limit(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "lua_time_limit", value) + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @max_disk_threshold.setter + def max_disk_threshold(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_disk_threshold", value) + + @property + @pulumi.getter + def maxclients(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum number of clients. + """ + return pulumi.get(self, "maxclients") + + @maxclients.setter + def maxclients(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "maxclients", value) + + @property + @pulumi.getter(name="maxmemoryPolicy") + def maxmemory_policy(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The policy to handle the maximum memory (volatile-lru, noeviction, etc). + """ + return pulumi.get(self, "maxmemory_policy") + + @maxmemory_policy.setter + def maxmemory_policy(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "maxmemory_policy", value) + + @property + @pulumi.getter(name="maxmemorySamples") + def maxmemory_samples(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximum memory samples. + """ + return pulumi.get(self, "maxmemory_samples") + + @maxmemory_samples.setter + def maxmemory_samples(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "maxmemory_samples", value) + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @metrics_frequency.setter + def metrics_frequency(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_frequency", value) + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @metrics_prefix.setter + def metrics_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_prefix", value) + + @property + @pulumi.getter(name="minReplicasMaxLag") + def min_replicas_max_lag(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimum replicas maximum lag. + """ + return pulumi.get(self, "min_replicas_max_lag") + + @min_replicas_max_lag.setter + def min_replicas_max_lag(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_replicas_max_lag", value) + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @monitoring_instance_id.setter + def monitoring_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "monitoring_instance_id", value) + + @property + @pulumi.getter(name="notifyKeyspaceEvents") + def notify_keyspace_events(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The notify keyspace events. + """ + return pulumi.get(self, "notify_keyspace_events") + + @notify_keyspace_events.setter + def notify_keyspace_events(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "notify_keyspace_events", value) + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @sgw_acl.setter + def sgw_acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sgw_acl", value) + + @property + @pulumi.getter + def snapshot(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The snapshot configuration. + """ + return pulumi.get(self, "snapshot") + + @snapshot.setter + def snapshot(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "snapshot", value) + + @property + @pulumi.getter + def syslogs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @syslogs.setter + def syslogs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "syslogs", value) + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @tls_ciphers.setter + def tls_ciphers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "tls_ciphers", value) + + @property + @pulumi.getter(name="tlsCiphersuites") + def tls_ciphersuites(self) -> Optional[pulumi.Input[builtins.str]]: + """ + TLS cipher suites to use. + """ + return pulumi.get(self, "tls_ciphersuites") + + @tls_ciphersuites.setter + def tls_ciphersuites(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "tls_ciphersuites", value) + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[pulumi.Input[builtins.str]]: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + @tls_protocols.setter + def tls_protocols(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "tls_protocols", value) + + +if not MYPY: + class SecurityGroupRuleIcmpParametersArgsDict(TypedDict): + code: pulumi.Input[builtins.int] + """ + ICMP code. Can be set if the protocol is ICMP. + """ + type: pulumi.Input[builtins.int] + """ + ICMP type. Can be set if the protocol is ICMP. + """ +elif False: + SecurityGroupRuleIcmpParametersArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SecurityGroupRuleIcmpParametersArgs: + def __init__(__self__, *, + code: pulumi.Input[builtins.int], + type: pulumi.Input[builtins.int]): + """ + :param pulumi.Input[builtins.int] code: ICMP code. Can be set if the protocol is ICMP. + :param pulumi.Input[builtins.int] type: ICMP type. Can be set if the protocol is ICMP. + """ + pulumi.set(__self__, "code", code) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def code(self) -> pulumi.Input[builtins.int]: + """ + ICMP code. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "code") + + @code.setter + def code(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "code", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[builtins.int]: + """ + ICMP type. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "type", value) + + +if not MYPY: + class SecurityGroupRulePortRangeArgsDict(TypedDict): + max: pulumi.Input[builtins.int] + """ + The maximum port number. Should be greater or equal to the minimum. + """ + min: pulumi.Input[builtins.int] + """ + The minimum port number. Should be less or equal to the maximum. + """ +elif False: + SecurityGroupRulePortRangeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SecurityGroupRulePortRangeArgs: + def __init__(__self__, *, + max: pulumi.Input[builtins.int], + min: pulumi.Input[builtins.int]): + """ + :param pulumi.Input[builtins.int] max: The maximum port number. Should be greater or equal to the minimum. + :param pulumi.Input[builtins.int] min: The minimum port number. Should be less or equal to the maximum. + """ + pulumi.set(__self__, "max", max) + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> pulumi.Input[builtins.int]: + """ + The maximum port number. Should be greater or equal to the minimum. + """ + return pulumi.get(self, "max") + + @max.setter + def max(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "max", value) + + @property + @pulumi.getter + def min(self) -> pulumi.Input[builtins.int]: + """ + The minimum port number. Should be less or equal to the maximum. + """ + return pulumi.get(self, "min") + + @min.setter + def min(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "min", value) + + +if not MYPY: + class SecurityGroupRuleProtocolArgsDict(TypedDict): + name: NotRequired[pulumi.Input[builtins.str]] + """ + The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + """ + number: NotRequired[pulumi.Input[builtins.int]] + """ + The protocol number which the rule should match. Either `name` or `number` must be provided. + """ +elif False: + SecurityGroupRuleProtocolArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SecurityGroupRuleProtocolArgs: + def __init__(__self__, *, + name: Optional[pulumi.Input[builtins.str]] = None, + number: Optional[pulumi.Input[builtins.int]] = None): + """ + :param pulumi.Input[builtins.str] name: The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + :param pulumi.Input[builtins.int] number: The protocol number which the rule should match. Either `name` or `number` must be provided. + """ + if name is not None: + pulumi.set(__self__, "name", name) + if number is not None: + pulumi.set(__self__, "number", number) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def number(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The protocol number which the rule should match. Either `name` or `number` must be provided. + """ + return pulumi.get(self, "number") + + @number.setter + def number(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "number", value) + + +if not MYPY: + class ServerBackupScheduleBackupPropertiesArgsDict(TypedDict): + name: pulumi.Input[builtins.str] + retention_period: pulumi.Input[builtins.int] + volume_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] +elif False: + ServerBackupScheduleBackupPropertiesArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ServerBackupScheduleBackupPropertiesArgs: + def __init__(__self__, *, + name: pulumi.Input[builtins.str], + retention_period: pulumi.Input[builtins.int], + volume_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "retention_period", retention_period) + if volume_ids is not None: + pulumi.set(__self__, "volume_ids", volume_ids) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="retentionPeriod") + def retention_period(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "retention_period") + + @retention_period.setter + def retention_period(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "retention_period", value) + + @property + @pulumi.getter(name="volumeIds") + def volume_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "volume_ids") + + @volume_ids.setter + def volume_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "volume_ids", value) + + +if not MYPY: + class ServerBootVolumeArgsDict(TypedDict): + source_id: pulumi.Input[builtins.str] + """ + The ID of the source, either image ID or volume ID + """ + source_type: pulumi.Input[builtins.str] + """ + The type of the source. Supported values are: `volume`, `image`. + """ + delete_on_termination: NotRequired[pulumi.Input[builtins.bool]] + """ + Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + """ + id: NotRequired[pulumi.Input[builtins.str]] + """ + The ID of the boot volume + """ + performance_class: NotRequired[pulumi.Input[builtins.str]] + """ + The performance class of the server. + """ + size: NotRequired[pulumi.Input[builtins.int]] + """ + The size of the boot volume in GB. Must be provided when `source_type` is `image`. + """ +elif False: + ServerBootVolumeArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class ServerBootVolumeArgs: + def __init__(__self__, *, + source_id: pulumi.Input[builtins.str], + source_type: pulumi.Input[builtins.str], + delete_on_termination: Optional[pulumi.Input[builtins.bool]] = None, + id: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None): + """ + :param pulumi.Input[builtins.str] source_id: The ID of the source, either image ID or volume ID + :param pulumi.Input[builtins.str] source_type: The type of the source. Supported values are: `volume`, `image`. + :param pulumi.Input[builtins.bool] delete_on_termination: Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + :param pulumi.Input[builtins.str] id: The ID of the boot volume + :param pulumi.Input[builtins.str] performance_class: The performance class of the server. + :param pulumi.Input[builtins.int] size: The size of the boot volume in GB. Must be provided when `source_type` is `image`. + """ + pulumi.set(__self__, "source_id", source_id) + pulumi.set(__self__, "source_type", source_type) + if delete_on_termination is not None: + pulumi.set(__self__, "delete_on_termination", delete_on_termination) + if id is not None: + pulumi.set(__self__, "id", id) + if performance_class is not None: + pulumi.set(__self__, "performance_class", performance_class) + if size is not None: + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="sourceId") + def source_id(self) -> pulumi.Input[builtins.str]: + """ + The ID of the source, either image ID or volume ID + """ + return pulumi.get(self, "source_id") + + @source_id.setter + def source_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "source_id", value) + + @property + @pulumi.getter(name="sourceType") + def source_type(self) -> pulumi.Input[builtins.str]: + """ + The type of the source. Supported values are: `volume`, `image`. + """ + return pulumi.get(self, "source_type") + + @source_type.setter + def source_type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "source_type", value) + + @property + @pulumi.getter(name="deleteOnTermination") + def delete_on_termination(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + """ + return pulumi.get(self, "delete_on_termination") + + @delete_on_termination.setter + def delete_on_termination(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "delete_on_termination", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the boot volume + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "id", value) + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The performance class of the server. + """ + return pulumi.get(self, "performance_class") + + @performance_class.setter + def performance_class(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "performance_class", value) + + @property + @pulumi.getter + def size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The size of the boot volume in GB. Must be provided when `source_type` is `image`. + """ + return pulumi.get(self, "size") + + @size.setter + def size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "size", value) + + +if not MYPY: + class SkeClusterExtensionsArgsDict(TypedDict): + acl: NotRequired[pulumi.Input['SkeClusterExtensionsAclArgsDict']] + """ + Cluster access control configuration. + """ + argus: NotRequired[pulumi.Input['SkeClusterExtensionsArgusArgsDict']] + """ + A single argus block as defined below. + """ + dns: NotRequired[pulumi.Input['SkeClusterExtensionsDnsArgsDict']] + """ + DNS extension configuration + """ +elif False: + SkeClusterExtensionsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterExtensionsArgs: + def __init__(__self__, *, + acl: Optional[pulumi.Input['SkeClusterExtensionsAclArgs']] = None, + argus: Optional[pulumi.Input['SkeClusterExtensionsArgusArgs']] = None, + dns: Optional[pulumi.Input['SkeClusterExtensionsDnsArgs']] = None): + """ + :param pulumi.Input['SkeClusterExtensionsAclArgs'] acl: Cluster access control configuration. + :param pulumi.Input['SkeClusterExtensionsArgusArgs'] argus: A single argus block as defined below. + :param pulumi.Input['SkeClusterExtensionsDnsArgs'] dns: DNS extension configuration + """ + if acl is not None: + pulumi.set(__self__, "acl", acl) + if argus is not None: + pulumi.set(__self__, "argus", argus) + if dns is not None: + pulumi.set(__self__, "dns", dns) + + @property + @pulumi.getter + def acl(self) -> Optional[pulumi.Input['SkeClusterExtensionsAclArgs']]: + """ + Cluster access control configuration. + """ + return pulumi.get(self, "acl") + + @acl.setter + def acl(self, value: Optional[pulumi.Input['SkeClusterExtensionsAclArgs']]): + pulumi.set(self, "acl", value) + + @property + @pulumi.getter + def argus(self) -> Optional[pulumi.Input['SkeClusterExtensionsArgusArgs']]: + """ + A single argus block as defined below. + """ + return pulumi.get(self, "argus") + + @argus.setter + def argus(self, value: Optional[pulumi.Input['SkeClusterExtensionsArgusArgs']]): + pulumi.set(self, "argus", value) + + @property + @pulumi.getter + def dns(self) -> Optional[pulumi.Input['SkeClusterExtensionsDnsArgs']]: + """ + DNS extension configuration + """ + return pulumi.get(self, "dns") + + @dns.setter + def dns(self, value: Optional[pulumi.Input['SkeClusterExtensionsDnsArgs']]): + pulumi.set(self, "dns", value) + + +if not MYPY: + class SkeClusterExtensionsAclArgsDict(TypedDict): + allowed_cidrs: pulumi.Input[Sequence[pulumi.Input[builtins.str]]] + """ + Specify a list of CIDRs to whitelist. + """ + enabled: pulumi.Input[builtins.bool] + """ + Is ACL enabled? + """ +elif False: + SkeClusterExtensionsAclArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterExtensionsAclArgs: + def __init__(__self__, *, + allowed_cidrs: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + enabled: pulumi.Input[builtins.bool]): + """ + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_cidrs: Specify a list of CIDRs to whitelist. + :param pulumi.Input[builtins.bool] enabled: Is ACL enabled? + """ + pulumi.set(__self__, "allowed_cidrs", allowed_cidrs) + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="allowedCidrs") + def allowed_cidrs(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Specify a list of CIDRs to whitelist. + """ + return pulumi.get(self, "allowed_cidrs") + + @allowed_cidrs.setter + def allowed_cidrs(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "allowed_cidrs", value) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[builtins.bool]: + """ + Is ACL enabled? + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "enabled", value) + + +if not MYPY: + class SkeClusterExtensionsArgusArgsDict(TypedDict): + enabled: pulumi.Input[builtins.bool] + """ + Flag to enable/disable Argus extensions. + """ + argus_instance_id: NotRequired[pulumi.Input[builtins.str]] + """ + Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + """ +elif False: + SkeClusterExtensionsArgusArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterExtensionsArgusArgs: + def __init__(__self__, *, + enabled: pulumi.Input[builtins.bool], + argus_instance_id: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.bool] enabled: Flag to enable/disable Argus extensions. + :param pulumi.Input[builtins.str] argus_instance_id: Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + """ + pulumi.set(__self__, "enabled", enabled) + if argus_instance_id is not None: + pulumi.set(__self__, "argus_instance_id", argus_instance_id) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[builtins.bool]: + """ + Flag to enable/disable Argus extensions. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="argusInstanceId") + def argus_instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + """ + return pulumi.get(self, "argus_instance_id") + + @argus_instance_id.setter + def argus_instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "argus_instance_id", value) + + +if not MYPY: + class SkeClusterExtensionsDnsArgsDict(TypedDict): + enabled: pulumi.Input[builtins.bool] + """ + Flag to enable/disable DNS extensions + """ + zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] + """ + Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ +elif False: + SkeClusterExtensionsDnsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterExtensionsDnsArgs: + def __init__(__self__, *, + enabled: pulumi.Input[builtins.bool], + zones: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + """ + :param pulumi.Input[builtins.bool] enabled: Flag to enable/disable DNS extensions + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] zones: Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + pulumi.set(__self__, "enabled", enabled) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[builtins.bool]: + """ + Flag to enable/disable DNS extensions + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter + def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + return pulumi.get(self, "zones") + + @zones.setter + def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "zones", value) + + +if not MYPY: + class SkeClusterHibernationArgsDict(TypedDict): + end: pulumi.Input[builtins.str] + """ + End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + """ + start: pulumi.Input[builtins.str] + """ + Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + """ + timezone: NotRequired[pulumi.Input[builtins.str]] + """ + Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + """ +elif False: + SkeClusterHibernationArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterHibernationArgs: + def __init__(__self__, *, + end: pulumi.Input[builtins.str], + start: pulumi.Input[builtins.str], + timezone: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] end: End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + :param pulumi.Input[builtins.str] start: Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + :param pulumi.Input[builtins.str] timezone: Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + """ + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + if timezone is not None: + pulumi.set(__self__, "timezone", timezone) + + @property + @pulumi.getter + def end(self) -> pulumi.Input[builtins.str]: + """ + End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + """ + return pulumi.get(self, "end") + + @end.setter + def end(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "end", value) + + @property + @pulumi.getter + def start(self) -> pulumi.Input[builtins.str]: + """ + Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + """ + return pulumi.get(self, "start") + + @start.setter + def start(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "start", value) + + @property + @pulumi.getter + def timezone(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + """ + return pulumi.get(self, "timezone") + + @timezone.setter + def timezone(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "timezone", value) + + +if not MYPY: + class SkeClusterMaintenanceArgsDict(TypedDict): + end: pulumi.Input[builtins.str] + """ + Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + start: pulumi.Input[builtins.str] + """ + Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + enable_kubernetes_version_updates: NotRequired[pulumi.Input[builtins.bool]] + """ + Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + enable_machine_image_version_updates: NotRequired[pulumi.Input[builtins.bool]] + """ + Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ +elif False: + SkeClusterMaintenanceArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterMaintenanceArgs: + def __init__(__self__, *, + end: pulumi.Input[builtins.str], + start: pulumi.Input[builtins.str], + enable_kubernetes_version_updates: Optional[pulumi.Input[builtins.bool]] = None, + enable_machine_image_version_updates: Optional[pulumi.Input[builtins.bool]] = None): + """ + :param pulumi.Input[builtins.str] end: Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + :param pulumi.Input[builtins.str] start: Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + :param pulumi.Input[builtins.bool] enable_kubernetes_version_updates: Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param pulumi.Input[builtins.bool] enable_machine_image_version_updates: Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + if enable_kubernetes_version_updates is not None: + pulumi.set(__self__, "enable_kubernetes_version_updates", enable_kubernetes_version_updates) + if enable_machine_image_version_updates is not None: + pulumi.set(__self__, "enable_machine_image_version_updates", enable_machine_image_version_updates) + + @property + @pulumi.getter + def end(self) -> pulumi.Input[builtins.str]: + """ + Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + return pulumi.get(self, "end") + + @end.setter + def end(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "end", value) + + @property + @pulumi.getter + def start(self) -> pulumi.Input[builtins.str]: + """ + Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + return pulumi.get(self, "start") + + @start.setter + def start(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "start", value) + + @property + @pulumi.getter(name="enableKubernetesVersionUpdates") + def enable_kubernetes_version_updates(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "enable_kubernetes_version_updates") + + @enable_kubernetes_version_updates.setter + def enable_kubernetes_version_updates(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_kubernetes_version_updates", value) + + @property + @pulumi.getter(name="enableMachineImageVersionUpdates") + def enable_machine_image_version_updates(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "enable_machine_image_version_updates") + + @enable_machine_image_version_updates.setter + def enable_machine_image_version_updates(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_machine_image_version_updates", value) + + +if not MYPY: + class SkeClusterNetworkArgsDict(TypedDict): + id: NotRequired[pulumi.Input[builtins.str]] + """ + ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ +elif False: + SkeClusterNetworkArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterNetworkArgs: + def __init__(__self__, *, + id: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] id: ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "id", value) + + +if not MYPY: + class SkeClusterNodePoolArgsDict(TypedDict): + availability_zones: pulumi.Input[Sequence[pulumi.Input[builtins.str]]] + """ + Specify a list of availability zones. E.g. `eu01-m` + """ + machine_type: pulumi.Input[builtins.str] + """ + The machine type. + """ + maximum: pulumi.Input[builtins.int] + """ + Maximum number of nodes in the pool. + """ + minimum: pulumi.Input[builtins.int] + """ + Minimum number of nodes in the pool. + """ + name: pulumi.Input[builtins.str] + """ + Specifies the name of the node pool. + """ + allow_system_components: NotRequired[pulumi.Input[builtins.bool]] + """ + Allow system components to run on this node pool. + """ + cri: NotRequired[pulumi.Input[builtins.str]] + """ + Specifies the container runtime. Defaults to `containerd` + """ + labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] + """ + Labels to add to each node. + """ + max_surge: NotRequired[pulumi.Input[builtins.int]] + """ + Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + max_unavailable: NotRequired[pulumi.Input[builtins.int]] + """ + Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + os_name: NotRequired[pulumi.Input[builtins.str]] + """ + The name of the OS image. Defaults to `flatcar`. + """ + os_version: NotRequired[pulumi.Input[builtins.str]] + """ + This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + """ + os_version_min: NotRequired[pulumi.Input[builtins.str]] + """ + The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + """ + os_version_used: NotRequired[pulumi.Input[builtins.str]] + """ + Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + taints: NotRequired[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolTaintArgsDict']]]] + """ + Specifies a taint list as defined below. + """ + volume_size: NotRequired[pulumi.Input[builtins.int]] + """ + The volume size in GB. Defaults to `20` + """ + volume_type: NotRequired[pulumi.Input[builtins.str]] + """ + Specifies the volume type. Defaults to `storage_premium_perf1`. + """ +elif False: + SkeClusterNodePoolArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterNodePoolArgs: + def __init__(__self__, *, + availability_zones: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + machine_type: pulumi.Input[builtins.str], + maximum: pulumi.Input[builtins.int], + minimum: pulumi.Input[builtins.int], + name: pulumi.Input[builtins.str], + allow_system_components: Optional[pulumi.Input[builtins.bool]] = None, + cri: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_surge: Optional[pulumi.Input[builtins.int]] = None, + max_unavailable: Optional[pulumi.Input[builtins.int]] = None, + os_name: Optional[pulumi.Input[builtins.str]] = None, + os_version: Optional[pulumi.Input[builtins.str]] = None, + os_version_min: Optional[pulumi.Input[builtins.str]] = None, + os_version_used: Optional[pulumi.Input[builtins.str]] = None, + taints: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolTaintArgs']]]] = None, + volume_size: Optional[pulumi.Input[builtins.int]] = None, + volume_type: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] availability_zones: Specify a list of availability zones. E.g. `eu01-m` + :param pulumi.Input[builtins.str] machine_type: The machine type. + :param pulumi.Input[builtins.int] maximum: Maximum number of nodes in the pool. + :param pulumi.Input[builtins.int] minimum: Minimum number of nodes in the pool. + :param pulumi.Input[builtins.str] name: Specifies the name of the node pool. + :param pulumi.Input[builtins.bool] allow_system_components: Allow system components to run on this node pool. + :param pulumi.Input[builtins.str] cri: Specifies the container runtime. Defaults to `containerd` + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels to add to each node. + :param pulumi.Input[builtins.int] max_surge: Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + :param pulumi.Input[builtins.int] max_unavailable: Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + :param pulumi.Input[builtins.str] os_name: The name of the OS image. Defaults to `flatcar`. + :param pulumi.Input[builtins.str] os_version: This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + :param pulumi.Input[builtins.str] os_version_min: The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + :param pulumi.Input[builtins.str] os_version_used: Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolTaintArgs']]] taints: Specifies a taint list as defined below. + :param pulumi.Input[builtins.int] volume_size: The volume size in GB. Defaults to `20` + :param pulumi.Input[builtins.str] volume_type: Specifies the volume type. Defaults to `storage_premium_perf1`. + """ + pulumi.set(__self__, "availability_zones", availability_zones) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "maximum", maximum) + pulumi.set(__self__, "minimum", minimum) + pulumi.set(__self__, "name", name) + if allow_system_components is not None: + pulumi.set(__self__, "allow_system_components", allow_system_components) + if cri is not None: + pulumi.set(__self__, "cri", cri) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if max_surge is not None: + pulumi.set(__self__, "max_surge", max_surge) + if max_unavailable is not None: + pulumi.set(__self__, "max_unavailable", max_unavailable) + if os_name is not None: + pulumi.set(__self__, "os_name", os_name) + if os_version is not None: + warnings.warn("""Use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates.""", DeprecationWarning) + pulumi.log.warn("""os_version is deprecated: Use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates.""") + if os_version is not None: + pulumi.set(__self__, "os_version", os_version) + if os_version_min is not None: + pulumi.set(__self__, "os_version_min", os_version_min) + if os_version_used is not None: + pulumi.set(__self__, "os_version_used", os_version_used) + if taints is not None: + pulumi.set(__self__, "taints", taints) + if volume_size is not None: + pulumi.set(__self__, "volume_size", volume_size) + if volume_type is not None: + pulumi.set(__self__, "volume_type", volume_type) + + @property + @pulumi.getter(name="availabilityZones") + def availability_zones(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Specify a list of availability zones. E.g. `eu01-m` + """ + return pulumi.get(self, "availability_zones") + + @availability_zones.setter + def availability_zones(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "availability_zones", value) + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> pulumi.Input[builtins.str]: + """ + The machine type. + """ + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "machine_type", value) + + @property + @pulumi.getter + def maximum(self) -> pulumi.Input[builtins.int]: + """ + Maximum number of nodes in the pool. + """ + return pulumi.get(self, "maximum") + + @maximum.setter + def maximum(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "maximum", value) + + @property + @pulumi.getter + def minimum(self) -> pulumi.Input[builtins.int]: + """ + Minimum number of nodes in the pool. + """ + return pulumi.get(self, "minimum") + + @minimum.setter + def minimum(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "minimum", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[builtins.str]: + """ + Specifies the name of the node pool. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="allowSystemComponents") + def allow_system_components(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Allow system components to run on this node pool. + """ + return pulumi.get(self, "allow_system_components") + + @allow_system_components.setter + def allow_system_components(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "allow_system_components", value) + + @property + @pulumi.getter + def cri(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the container runtime. Defaults to `containerd` + """ + return pulumi.get(self, "cri") + + @cri.setter + def cri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cri", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels to add to each node. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="maxSurge") + def max_surge(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + return pulumi.get(self, "max_surge") + + @max_surge.setter + def max_surge(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_surge", value) + + @property + @pulumi.getter(name="maxUnavailable") + def max_unavailable(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + return pulumi.get(self, "max_unavailable") + + @max_unavailable.setter + def max_unavailable(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_unavailable", value) + + @property + @pulumi.getter(name="osName") + def os_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the OS image. Defaults to `flatcar`. + """ + return pulumi.get(self, "os_name") + + @os_name.setter + def os_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "os_name", value) + + @property + @pulumi.getter(name="osVersion") + @_utilities.deprecated("""Use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates.""") + def os_version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + """ + return pulumi.get(self, "os_version") + + @os_version.setter + def os_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "os_version", value) + + @property + @pulumi.getter(name="osVersionMin") + def os_version_min(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + """ + return pulumi.get(self, "os_version_min") + + @os_version_min.setter + def os_version_min(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "os_version_min", value) + + @property + @pulumi.getter(name="osVersionUsed") + def os_version_used(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "os_version_used") + + @os_version_used.setter + def os_version_used(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "os_version_used", value) + + @property + @pulumi.getter + def taints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolTaintArgs']]]]: + """ + Specifies a taint list as defined below. + """ + return pulumi.get(self, "taints") + + @taints.setter + def taints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolTaintArgs']]]]): + pulumi.set(self, "taints", value) + + @property + @pulumi.getter(name="volumeSize") + def volume_size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The volume size in GB. Defaults to `20` + """ + return pulumi.get(self, "volume_size") + + @volume_size.setter + def volume_size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "volume_size", value) + + @property + @pulumi.getter(name="volumeType") + def volume_type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the volume type. Defaults to `storage_premium_perf1`. + """ + return pulumi.get(self, "volume_type") + + @volume_type.setter + def volume_type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "volume_type", value) + + +if not MYPY: + class SkeClusterNodePoolTaintArgsDict(TypedDict): + effect: pulumi.Input[builtins.str] + """ + The taint effect. E.g `PreferNoSchedule`. + """ + key: pulumi.Input[builtins.str] + """ + Taint key to be applied to a node. + """ + value: NotRequired[pulumi.Input[builtins.str]] + """ + Taint value corresponding to the taint key. + """ +elif False: + SkeClusterNodePoolTaintArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SkeClusterNodePoolTaintArgs: + def __init__(__self__, *, + effect: pulumi.Input[builtins.str], + key: pulumi.Input[builtins.str], + value: Optional[pulumi.Input[builtins.str]] = None): + """ + :param pulumi.Input[builtins.str] effect: The taint effect. E.g `PreferNoSchedule`. + :param pulumi.Input[builtins.str] key: Taint key to be applied to a node. + :param pulumi.Input[builtins.str] value: Taint value corresponding to the taint key. + """ + pulumi.set(__self__, "effect", effect) + pulumi.set(__self__, "key", key) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def effect(self) -> pulumi.Input[builtins.str]: + """ + The taint effect. E.g `PreferNoSchedule`. + """ + return pulumi.get(self, "effect") + + @effect.setter + def effect(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "effect", value) + + @property + @pulumi.getter + def key(self) -> pulumi.Input[builtins.str]: + """ + Taint key to be applied to a node. + """ + return pulumi.get(self, "key") + + @key.setter + def key(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "key", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Taint value corresponding to the taint key. + """ + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "value", value) + + +if not MYPY: + class SqlserverflexInstanceFlavorArgsDict(TypedDict): + cpu: pulumi.Input[builtins.int] + ram: pulumi.Input[builtins.int] + description: NotRequired[pulumi.Input[builtins.str]] + id: NotRequired[pulumi.Input[builtins.str]] +elif False: + SqlserverflexInstanceFlavorArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SqlserverflexInstanceFlavorArgs: + def __init__(__self__, *, + cpu: pulumi.Input[builtins.int], + ram: pulumi.Input[builtins.int], + description: Optional[pulumi.Input[builtins.str]] = None, + id: Optional[pulumi.Input[builtins.str]] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "cpu") + + @cpu.setter + def cpu(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "cpu", value) + + @property + @pulumi.getter + def ram(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "ram") + + @ram.setter + def ram(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "ram", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "id", value) + + +if not MYPY: + class SqlserverflexInstanceOptionsArgsDict(TypedDict): + edition: NotRequired[pulumi.Input[builtins.str]] + retention_days: NotRequired[pulumi.Input[builtins.int]] +elif False: + SqlserverflexInstanceOptionsArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SqlserverflexInstanceOptionsArgs: + def __init__(__self__, *, + edition: Optional[pulumi.Input[builtins.str]] = None, + retention_days: Optional[pulumi.Input[builtins.int]] = None): + if edition is not None: + pulumi.set(__self__, "edition", edition) + if retention_days is not None: + pulumi.set(__self__, "retention_days", retention_days) + + @property + @pulumi.getter + def edition(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "edition") + + @edition.setter + def edition(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "edition", value) + + @property + @pulumi.getter(name="retentionDays") + def retention_days(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "retention_days") + + @retention_days.setter + def retention_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "retention_days", value) + + +if not MYPY: + class SqlserverflexInstanceStorageArgsDict(TypedDict): + class_: NotRequired[pulumi.Input[builtins.str]] + size: NotRequired[pulumi.Input[builtins.int]] +elif False: + SqlserverflexInstanceStorageArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class SqlserverflexInstanceStorageArgs: + def __init__(__self__, *, + class_: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None): + if class_ is not None: + pulumi.set(__self__, "class_", class_) + if size is not None: + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "class_") + + @class_.setter + def class_(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "class_", value) + + @property + @pulumi.getter + def size(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "size") + + @size.setter + def size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "size", value) + + +if not MYPY: + class VolumeSourceArgsDict(TypedDict): + id: pulumi.Input[builtins.str] + """ + The ID of the source, e.g. image ID + """ + type: pulumi.Input[builtins.str] + """ + The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ +elif False: + VolumeSourceArgsDict: TypeAlias = Mapping[str, Any] + +@pulumi.input_type +class VolumeSourceArgs: + def __init__(__self__, *, + id: pulumi.Input[builtins.str], + type: pulumi.Input[builtins.str]): + """ + :param pulumi.Input[builtins.str] id: The ID of the source, e.g. image ID + :param pulumi.Input[builtins.str] type: The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def id(self) -> pulumi.Input[builtins.str]: + """ + The ID of the source, e.g. image ID + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "id", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[builtins.str]: + """ + The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "type", value) + + diff --git a/sdk/python/pulumi_stackit/_utilities.py b/sdk/python/pulumi_stackit/_utilities.py new file mode 100644 index 0000000..8d1e8c2 --- /dev/null +++ b/sdk/python/pulumi_stackit/_utilities.py @@ -0,0 +1,331 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + + +import asyncio +import functools +import importlib.metadata +import importlib.util +import inspect +import json +import os +import sys +import typing +import warnings +import base64 + +import pulumi +import pulumi.runtime +from pulumi.runtime.sync_await import _sync_await +from pulumi.runtime.proto import resource_pb2 + +from semver import VersionInfo as SemverVersion +from parver import Version as PEP440Version + +C = typing.TypeVar("C", bound=typing.Callable) + + +def get_env(*args): + for v in args: + value = os.getenv(v) + if value is not None: + return value + return None + + +def get_env_bool(*args): + str = get_env(*args) + if str is not None: + # NOTE: these values are taken from https://golang.org/src/strconv/atob.go?s=351:391#L1, which is what + # Terraform uses internally when parsing boolean values. + if str in ["1", "t", "T", "true", "TRUE", "True"]: + return True + if str in ["0", "f", "F", "false", "FALSE", "False"]: + return False + return None + + +def get_env_int(*args): + str = get_env(*args) + if str is not None: + try: + return int(str) + except: + return None + return None + + +def get_env_float(*args): + str = get_env(*args) + if str is not None: + try: + return float(str) + except: + return None + return None + + +def _get_semver_version(): + # __name__ is set to the fully-qualified name of the current module, In our case, it will be + # ._utilities. is the module we want to query the version for. + root_package, *rest = __name__.split('.') + + # pkg_resources uses setuptools to inspect the set of installed packages. We use it here to ask + # for the currently installed version of the root package (i.e. us) and get its version. + + # Unfortunately, PEP440 and semver differ slightly in incompatible ways. The Pulumi engine expects + # to receive a valid semver string when receiving requests from the language host, so it's our + # responsibility as the library to convert our own PEP440 version into a valid semver string. + + pep440_version_string = importlib.metadata.version(root_package) + pep440_version = PEP440Version.parse(pep440_version_string) + (major, minor, patch) = pep440_version.release + prerelease = None + if pep440_version.pre_tag == 'a': + prerelease = f"alpha.{pep440_version.pre}" + elif pep440_version.pre_tag == 'b': + prerelease = f"beta.{pep440_version.pre}" + elif pep440_version.pre_tag == 'rc': + prerelease = f"rc.{pep440_version.pre}" + elif pep440_version.dev is not None: + # PEP440 has explicit support for dev builds, while semver encodes them as "prerelease" versions. To bridge + # between the two, we convert our dev build version into a prerelease tag. This matches what all of our other + # packages do when constructing their own semver string. + prerelease = f"dev.{pep440_version.dev}" + elif pep440_version.local is not None: + # PEP440 only allows a small set of prerelease tags, so when converting an arbitrary prerelease, + # PypiVersion in /pkg/codegen/python/utilities.go converts it to a local version. Therefore, we need to + # do the reverse conversion here and set the local version as the prerelease tag. + prerelease = pep440_version.local + + return SemverVersion(major=major, minor=minor, patch=patch, prerelease=prerelease) + + +# Determine the version once and cache the value, which measurably improves program performance. +_version = _get_semver_version() +_version_str = str(_version) + +def get_resource_opts_defaults() -> pulumi.ResourceOptions: + return pulumi.ResourceOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_invoke_opts_defaults() -> pulumi.InvokeOptions: + return pulumi.InvokeOptions( + version=get_version(), + plugin_download_url=get_plugin_download_url(), + ) + +def get_resource_args_opts(resource_args_type, resource_options_type, *args, **kwargs): + """ + Return the resource args and options given the *args and **kwargs of a resource's + __init__ method. + """ + + resource_args, opts = None, None + + # If the first item is the resource args type, save it and remove it from the args list. + if args and isinstance(args[0], resource_args_type): + resource_args, args = args[0], args[1:] + + # Now look at the first item in the args list again. + # If the first item is the resource options class, save it. + if args and isinstance(args[0], resource_options_type): + opts = args[0] + + # If resource_args is None, see if "args" is in kwargs, and, if so, if it's typed as the + # the resource args type. + if resource_args is None: + a = kwargs.get("args") + if isinstance(a, resource_args_type): + resource_args = a + + # If opts is None, look it up in kwargs. + if opts is None: + opts = kwargs.get("opts") + + return resource_args, opts + + +# Temporary: just use pulumi._utils.lazy_import once everyone upgrades. +def lazy_import(fullname): + + import pulumi._utils as u + f = getattr(u, 'lazy_import', None) + if f is None: + f = _lazy_import_temp + + return f(fullname) + + +# Copied from pulumi._utils.lazy_import, see comments there. +def _lazy_import_temp(fullname): + m = sys.modules.get(fullname, None) + if m is not None: + return m + + spec = importlib.util.find_spec(fullname) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + loader = importlib.util.LazyLoader(spec.loader) + spec.loader = loader + module = importlib.util.module_from_spec(spec) + + m = sys.modules.get(fullname, None) + if m is not None: + return m + + sys.modules[fullname] = module + loader.exec_module(module) + return module + + +class Package(pulumi.runtime.ResourcePackage): + def __init__(self, pkg_info): + super().__init__() + self.pkg_info = pkg_info + + def version(self): + return _version + + def construct_provider(self, name: str, typ: str, urn: str) -> pulumi.ProviderResource: + if typ != self.pkg_info['token']: + raise Exception(f"unknown provider type {typ}") + Provider = getattr(lazy_import(self.pkg_info['fqn']), self.pkg_info['class']) + return Provider(name, pulumi.ResourceOptions(urn=urn)) + + +class Module(pulumi.runtime.ResourceModule): + def __init__(self, mod_info): + super().__init__() + self.mod_info = mod_info + + def version(self): + return _version + + def construct(self, name: str, typ: str, urn: str) -> pulumi.Resource: + class_name = self.mod_info['classes'].get(typ, None) + + if class_name is None: + raise Exception(f"unknown resource type {typ}") + + TheClass = getattr(lazy_import(self.mod_info['fqn']), class_name) + return TheClass(name, pulumi.ResourceOptions(urn=urn)) + + +def register(resource_modules, resource_packages): + resource_modules = json.loads(resource_modules) + resource_packages = json.loads(resource_packages) + + for pkg_info in resource_packages: + pulumi.runtime.register_resource_package(pkg_info['pkg'], Package(pkg_info)) + + for mod_info in resource_modules: + pulumi.runtime.register_resource_module( + mod_info['pkg'], + mod_info['mod'], + Module(mod_info)) + + +_F = typing.TypeVar('_F', bound=typing.Callable[..., typing.Any]) + + +def lift_output_func(func: typing.Any) -> typing.Callable[[_F], _F]: + """Decorator internally used on {fn}_output lifted function versions + to implement them automatically from the un-lifted function.""" + + func_sig = inspect.signature(func) + + def lifted_func(*args, opts=None, **kwargs): + bound_args = func_sig.bind(*args, **kwargs) + # Convert tuple to list, see pulumi/pulumi#8172 + args_list = list(bound_args.args) + return pulumi.Output.from_input({ + 'args': args_list, + 'kwargs': bound_args.kwargs + }).apply(lambda resolved_args: func(*resolved_args['args'], + opts=opts, + **resolved_args['kwargs'])) + + return (lambda _: lifted_func) + + +def call_plain( + tok: str, + props: pulumi.Inputs, + res: typing.Optional[pulumi.Resource] = None, + typ: typing.Optional[type] = None, +) -> typing.Any: + """ + Wraps pulumi.runtime.plain to force the output and return it plainly. + """ + + output = pulumi.runtime.call(tok, props, res, typ) + + # Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency. + result, known, secret, _ = _sync_await(asyncio.create_task(_await_output(output))) + + problem = None + if not known: + problem = ' an unknown value' + elif secret: + problem = ' a secret value' + + if problem: + raise AssertionError( + f"Plain resource method '{tok}' incorrectly returned {problem}. " + + "This is an error in the provider, please report this to the provider developer." + ) + + return result + + +async def _await_output(o: pulumi.Output[typing.Any]) -> typing.Tuple[object, bool, bool, set]: + return ( + await o._future, + await o._is_known, + await o._is_secret, + await o._resources, + ) + + +# This is included to provide an upgrade path for users who are using a version +# of the Pulumi SDK (<3.121.0) that does not include the `deprecated` decorator. +def deprecated(message: str) -> typing.Callable[[C], C]: + """ + Decorator to indicate a function is deprecated. + + As well as inserting appropriate statements to indicate that the function is + deprecated, this decorator also tags the function with a special attribute + so that Pulumi code can detect that it is deprecated and react appropriately + in certain situations. + + message is the deprecation message that should be printed if the function is called. + """ + + def decorator(fn: C) -> C: + if not callable(fn): + raise TypeError("Expected fn to be callable") + + @functools.wraps(fn) + def deprecated_fn(*args, **kwargs): + warnings.warn(message) + pulumi.warn(f"{fn.__name__} is deprecated: {message}") + + return fn(*args, **kwargs) + + deprecated_fn.__dict__["_pulumi_deprecated_callable"] = fn + return typing.cast(C, deprecated_fn) + + return decorator + +def get_plugin_download_url(): + return "github://api.github.com/stackitcloud/pulumi-stackit" + +def get_version(): + return _version_str diff --git a/sdk/python/pulumi_stackit/affinity_group.py b/sdk/python/pulumi_stackit/affinity_group.py new file mode 100644 index 0000000..5adac3b --- /dev/null +++ b/sdk/python/pulumi_stackit/affinity_group.py @@ -0,0 +1,308 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['AffinityGroupArgs', 'AffinityGroup'] + +@pulumi.input_type +class AffinityGroupArgs: + def __init__(__self__, *, + policy: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a AffinityGroup resource. + :param pulumi.Input[builtins.str] policy: The policy of the affinity group. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the affinity group is associated. + :param pulumi.Input[builtins.str] name: The name of the affinity group. + """ + pulumi.set(__self__, "policy", policy) + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def policy(self) -> pulumi.Input[builtins.str]: + """ + The policy of the affinity group. + """ + return pulumi.get(self, "policy") + + @policy.setter + def policy(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "policy", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the affinity group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the affinity group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _AffinityGroupState: + def __init__(__self__, *, + affinity_group_id: Optional[pulumi.Input[builtins.str]] = None, + members: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + policy: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering AffinityGroup resources. + :param pulumi.Input[builtins.str] affinity_group_id: The affinity group ID. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] members: The servers that are part of the affinity group. + :param pulumi.Input[builtins.str] name: The name of the affinity group. + :param pulumi.Input[builtins.str] policy: The policy of the affinity group. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the affinity group is associated. + """ + if affinity_group_id is not None: + pulumi.set(__self__, "affinity_group_id", affinity_group_id) + if members is not None: + pulumi.set(__self__, "members", members) + if name is not None: + pulumi.set(__self__, "name", name) + if policy is not None: + pulumi.set(__self__, "policy", policy) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="affinityGroupId") + def affinity_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The affinity group ID. + """ + return pulumi.get(self, "affinity_group_id") + + @affinity_group_id.setter + def affinity_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "affinity_group_id", value) + + @property + @pulumi.getter + def members(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The servers that are part of the affinity group. + """ + return pulumi.get(self, "members") + + @members.setter + def members(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "members", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the affinity group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def policy(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The policy of the affinity group. + """ + return pulumi.get(self, "policy") + + @policy.setter + def policy(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "policy", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the affinity group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + +@pulumi.type_token("stackit:index/affinityGroup:AffinityGroup") +class AffinityGroup(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + policy: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Affinity Group schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: The name of the affinity group. + :param pulumi.Input[builtins.str] policy: The policy of the affinity group. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the affinity group is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: AffinityGroupArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Affinity Group schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param AffinityGroupArgs 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(AffinityGroupArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + policy: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = AffinityGroupArgs.__new__(AffinityGroupArgs) + + __props__.__dict__["name"] = name + if policy is None and not opts.urn: + raise TypeError("Missing required property 'policy'") + __props__.__dict__["policy"] = policy + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["affinity_group_id"] = None + __props__.__dict__["members"] = None + super(AffinityGroup, __self__).__init__( + 'stackit:index/affinityGroup:AffinityGroup', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + affinity_group_id: Optional[pulumi.Input[builtins.str]] = None, + members: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + policy: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None) -> 'AffinityGroup': + """ + Get an existing AffinityGroup 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[builtins.str] affinity_group_id: The affinity group ID. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] members: The servers that are part of the affinity group. + :param pulumi.Input[builtins.str] name: The name of the affinity group. + :param pulumi.Input[builtins.str] policy: The policy of the affinity group. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the affinity group is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _AffinityGroupState.__new__(_AffinityGroupState) + + __props__.__dict__["affinity_group_id"] = affinity_group_id + __props__.__dict__["members"] = members + __props__.__dict__["name"] = name + __props__.__dict__["policy"] = policy + __props__.__dict__["project_id"] = project_id + return AffinityGroup(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="affinityGroupId") + def affinity_group_id(self) -> pulumi.Output[builtins.str]: + """ + The affinity group ID. + """ + return pulumi.get(self, "affinity_group_id") + + @property + @pulumi.getter + def members(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The servers that are part of the affinity group. + """ + return pulumi.get(self, "members") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the affinity group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def policy(self) -> pulumi.Output[builtins.str]: + """ + The policy of the affinity group. + """ + return pulumi.get(self, "policy") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the affinity group is associated. + """ + return pulumi.get(self, "project_id") + diff --git a/sdk/python/pulumi_stackit/authorization_organization_role_assignment.py b/sdk/python/pulumi_stackit/authorization_organization_role_assignment.py new file mode 100644 index 0000000..608718d --- /dev/null +++ b/sdk/python/pulumi_stackit/authorization_organization_role_assignment.py @@ -0,0 +1,257 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['AuthorizationOrganizationRoleAssignmentArgs', 'AuthorizationOrganizationRoleAssignment'] + +@pulumi.input_type +class AuthorizationOrganizationRoleAssignmentArgs: + def __init__(__self__, *, + resource_id: pulumi.Input[builtins.str], + role: pulumi.Input[builtins.str], + subject: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a AuthorizationOrganizationRoleAssignment resource. + :param pulumi.Input[builtins.str] resource_id: organization Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + pulumi.set(__self__, "resource_id", resource_id) + pulumi.set(__self__, "role", role) + pulumi.set(__self__, "subject", subject) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> pulumi.Input[builtins.str]: + """ + organization Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @resource_id.setter + def resource_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "resource_id", value) + + @property + @pulumi.getter + def role(self) -> pulumi.Input[builtins.str]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter + def subject(self) -> pulumi.Input[builtins.str]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + + @subject.setter + def subject(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "subject", value) + + +@pulumi.input_type +class _AuthorizationOrganizationRoleAssignmentState: + def __init__(__self__, *, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering AuthorizationOrganizationRoleAssignment resources. + :param pulumi.Input[builtins.str] resource_id: organization Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + if resource_id is not None: + pulumi.set(__self__, "resource_id", resource_id) + if role is not None: + pulumi.set(__self__, "role", role) + if subject is not None: + pulumi.set(__self__, "subject", subject) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + organization Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @resource_id.setter + def resource_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "resource_id", value) + + @property + @pulumi.getter + def role(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter + def subject(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + + @subject.setter + def subject(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "subject", value) + + +@pulumi.type_token("stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment") +class AuthorizationOrganizationRoleAssignment(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + organization Role Assignment resource schema. + + > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] resource_id: organization Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: AuthorizationOrganizationRoleAssignmentArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + organization Role Assignment resource schema. + + > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param AuthorizationOrganizationRoleAssignmentArgs 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(AuthorizationOrganizationRoleAssignmentArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.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__ = AuthorizationOrganizationRoleAssignmentArgs.__new__(AuthorizationOrganizationRoleAssignmentArgs) + + if resource_id is None and not opts.urn: + raise TypeError("Missing required property 'resource_id'") + __props__.__dict__["resource_id"] = resource_id + if role is None and not opts.urn: + raise TypeError("Missing required property 'role'") + __props__.__dict__["role"] = role + if subject is None and not opts.urn: + raise TypeError("Missing required property 'subject'") + __props__.__dict__["subject"] = subject + super(AuthorizationOrganizationRoleAssignment, __self__).__init__( + 'stackit:index/authorizationOrganizationRoleAssignment:AuthorizationOrganizationRoleAssignment', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None) -> 'AuthorizationOrganizationRoleAssignment': + """ + Get an existing AuthorizationOrganizationRoleAssignment 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[builtins.str] resource_id: organization Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _AuthorizationOrganizationRoleAssignmentState.__new__(_AuthorizationOrganizationRoleAssignmentState) + + __props__.__dict__["resource_id"] = resource_id + __props__.__dict__["role"] = role + __props__.__dict__["subject"] = subject + return AuthorizationOrganizationRoleAssignment(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> pulumi.Output[builtins.str]: + """ + organization Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @property + @pulumi.getter + def role(self) -> pulumi.Output[builtins.str]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @property + @pulumi.getter + def subject(self) -> pulumi.Output[builtins.str]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + diff --git a/sdk/python/pulumi_stackit/authorization_project_role_assignment.py b/sdk/python/pulumi_stackit/authorization_project_role_assignment.py new file mode 100644 index 0000000..ffdc63d --- /dev/null +++ b/sdk/python/pulumi_stackit/authorization_project_role_assignment.py @@ -0,0 +1,257 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['AuthorizationProjectRoleAssignmentArgs', 'AuthorizationProjectRoleAssignment'] + +@pulumi.input_type +class AuthorizationProjectRoleAssignmentArgs: + def __init__(__self__, *, + resource_id: pulumi.Input[builtins.str], + role: pulumi.Input[builtins.str], + subject: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a AuthorizationProjectRoleAssignment resource. + :param pulumi.Input[builtins.str] resource_id: project Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + pulumi.set(__self__, "resource_id", resource_id) + pulumi.set(__self__, "role", role) + pulumi.set(__self__, "subject", subject) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> pulumi.Input[builtins.str]: + """ + project Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @resource_id.setter + def resource_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "resource_id", value) + + @property + @pulumi.getter + def role(self) -> pulumi.Input[builtins.str]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter + def subject(self) -> pulumi.Input[builtins.str]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + + @subject.setter + def subject(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "subject", value) + + +@pulumi.input_type +class _AuthorizationProjectRoleAssignmentState: + def __init__(__self__, *, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering AuthorizationProjectRoleAssignment resources. + :param pulumi.Input[builtins.str] resource_id: project Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + if resource_id is not None: + pulumi.set(__self__, "resource_id", resource_id) + if role is not None: + pulumi.set(__self__, "role", role) + if subject is not None: + pulumi.set(__self__, "subject", subject) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + project Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @resource_id.setter + def resource_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "resource_id", value) + + @property + @pulumi.getter + def role(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @role.setter + def role(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "role", value) + + @property + @pulumi.getter + def subject(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + + @subject.setter + def subject(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "subject", value) + + +@pulumi.type_token("stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment") +class AuthorizationProjectRoleAssignment(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + project Role Assignment resource schema. + + > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] resource_id: project Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: AuthorizationProjectRoleAssignmentArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + project Role Assignment resource schema. + + > This resource is part of the iam experiment and is likely going to undergo significant changes or be removed in the future. Use it at your own discretion. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param AuthorizationProjectRoleAssignmentArgs 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(AuthorizationProjectRoleAssignmentArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.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__ = AuthorizationProjectRoleAssignmentArgs.__new__(AuthorizationProjectRoleAssignmentArgs) + + if resource_id is None and not opts.urn: + raise TypeError("Missing required property 'resource_id'") + __props__.__dict__["resource_id"] = resource_id + if role is None and not opts.urn: + raise TypeError("Missing required property 'role'") + __props__.__dict__["role"] = role + if subject is None and not opts.urn: + raise TypeError("Missing required property 'subject'") + __props__.__dict__["subject"] = subject + super(AuthorizationProjectRoleAssignment, __self__).__init__( + 'stackit:index/authorizationProjectRoleAssignment:AuthorizationProjectRoleAssignment', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + resource_id: Optional[pulumi.Input[builtins.str]] = None, + role: Optional[pulumi.Input[builtins.str]] = None, + subject: Optional[pulumi.Input[builtins.str]] = None) -> 'AuthorizationProjectRoleAssignment': + """ + Get an existing AuthorizationProjectRoleAssignment 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[builtins.str] resource_id: project Resource to assign the role to. + :param pulumi.Input[builtins.str] role: Role to be assigned + :param pulumi.Input[builtins.str] subject: Identifier of user, service account or client. Usually email address or name in case of clients + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _AuthorizationProjectRoleAssignmentState.__new__(_AuthorizationProjectRoleAssignmentState) + + __props__.__dict__["resource_id"] = resource_id + __props__.__dict__["role"] = role + __props__.__dict__["subject"] = subject + return AuthorizationProjectRoleAssignment(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="resourceId") + def resource_id(self) -> pulumi.Output[builtins.str]: + """ + project Resource to assign the role to. + """ + return pulumi.get(self, "resource_id") + + @property + @pulumi.getter + def role(self) -> pulumi.Output[builtins.str]: + """ + Role to be assigned + """ + return pulumi.get(self, "role") + + @property + @pulumi.getter + def subject(self) -> pulumi.Output[builtins.str]: + """ + Identifier of user, service account or client. Usually email address or name in case of clients + """ + return pulumi.get(self, "subject") + diff --git a/sdk/python/pulumi_stackit/cdn_custom_domain.py b/sdk/python/pulumi_stackit/cdn_custom_domain.py new file mode 100644 index 0000000..46c01f1 --- /dev/null +++ b/sdk/python/pulumi_stackit/cdn_custom_domain.py @@ -0,0 +1,299 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['CdnCustomDomainArgs', 'CdnCustomDomain'] + +@pulumi.input_type +class CdnCustomDomainArgs: + def __init__(__self__, *, + distribution_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a CdnCustomDomain resource. + :param pulumi.Input[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + """ + pulumi.set(__self__, "distribution_id", distribution_id) + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> pulumi.Input[builtins.str]: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @distribution_id.setter + def distribution_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "distribution_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _CdnCustomDomainState: + def __init__(__self__, *, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + errors: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + status: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering CdnCustomDomain resources. + :param pulumi.Input[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] errors: List of distribution errors + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + :param pulumi.Input[builtins.str] status: Status of the distribution + """ + if distribution_id is not None: + pulumi.set(__self__, "distribution_id", distribution_id) + if errors is not None: + pulumi.set(__self__, "errors", errors) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if status is not None: + pulumi.set(__self__, "status", status) + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @distribution_id.setter + def distribution_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "distribution_id", value) + + @property + @pulumi.getter + def errors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @errors.setter + def errors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "errors", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "status", value) + + +@pulumi.type_token("stackit:index/cdnCustomDomain:CdnCustomDomain") +class CdnCustomDomain(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: CdnCustomDomainArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param CdnCustomDomainArgs 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(CdnCustomDomainArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = CdnCustomDomainArgs.__new__(CdnCustomDomainArgs) + + if distribution_id is None and not opts.urn: + raise TypeError("Missing required property 'distribution_id'") + __props__.__dict__["distribution_id"] = distribution_id + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["errors"] = None + __props__.__dict__["status"] = None + super(CdnCustomDomain, __self__).__init__( + 'stackit:index/cdnCustomDomain:CdnCustomDomain', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + errors: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + status: Optional[pulumi.Input[builtins.str]] = None) -> 'CdnCustomDomain': + """ + Get an existing CdnCustomDomain 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[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] errors: List of distribution errors + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + :param pulumi.Input[builtins.str] status: Status of the distribution + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _CdnCustomDomainState.__new__(_CdnCustomDomainState) + + __props__.__dict__["distribution_id"] = distribution_id + __props__.__dict__["errors"] = errors + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["status"] = status + return CdnCustomDomain(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> pulumi.Output[builtins.str]: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @property + @pulumi.getter + def errors(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def status(self) -> pulumi.Output[builtins.str]: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + diff --git a/sdk/python/pulumi_stackit/cdn_distribution.py b/sdk/python/pulumi_stackit/cdn_distribution.py new file mode 100644 index 0000000..e30daea --- /dev/null +++ b/sdk/python/pulumi_stackit/cdn_distribution.py @@ -0,0 +1,379 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['CdnDistributionArgs', 'CdnDistribution'] + +@pulumi.input_type +class CdnDistributionArgs: + def __init__(__self__, *, + config: pulumi.Input['CdnDistributionConfigArgs'], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a CdnDistribution resource. + :param pulumi.Input['CdnDistributionConfigArgs'] config: The distribution configuration + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + """ + pulumi.set(__self__, "config", config) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter + def config(self) -> pulumi.Input['CdnDistributionConfigArgs']: + """ + The distribution configuration + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: pulumi.Input['CdnDistributionConfigArgs']): + pulumi.set(self, "config", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _CdnDistributionState: + def __init__(__self__, *, + config: Optional[pulumi.Input['CdnDistributionConfigArgs']] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + domains: Optional[pulumi.Input[Sequence[pulumi.Input['CdnDistributionDomainArgs']]]] = None, + errors: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + status: Optional[pulumi.Input[builtins.str]] = None, + updated_at: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering CdnDistribution resources. + :param pulumi.Input['CdnDistributionConfigArgs'] config: The distribution configuration + :param pulumi.Input[builtins.str] created_at: Time when the distribution was created + :param pulumi.Input[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[Sequence[pulumi.Input['CdnDistributionDomainArgs']]] domains: List of configured domains for the distribution + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] errors: List of distribution errors + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + :param pulumi.Input[builtins.str] status: Status of the distribution + :param pulumi.Input[builtins.str] updated_at: Time when the distribution was last updated + """ + if config is not None: + pulumi.set(__self__, "config", config) + if created_at is not None: + pulumi.set(__self__, "created_at", created_at) + if distribution_id is not None: + pulumi.set(__self__, "distribution_id", distribution_id) + if domains is not None: + pulumi.set(__self__, "domains", domains) + if errors is not None: + pulumi.set(__self__, "errors", errors) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if status is not None: + pulumi.set(__self__, "status", status) + if updated_at is not None: + pulumi.set(__self__, "updated_at", updated_at) + + @property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['CdnDistributionConfigArgs']]: + """ + The distribution configuration + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['CdnDistributionConfigArgs']]): + pulumi.set(self, "config", value) + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Time when the distribution was created + """ + return pulumi.get(self, "created_at") + + @created_at.setter + def created_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "created_at", value) + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @distribution_id.setter + def distribution_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "distribution_id", value) + + @property + @pulumi.getter + def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CdnDistributionDomainArgs']]]]: + """ + List of configured domains for the distribution + """ + return pulumi.get(self, "domains") + + @domains.setter + def domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CdnDistributionDomainArgs']]]]): + pulumi.set(self, "domains", value) + + @property + @pulumi.getter + def errors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @errors.setter + def errors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "errors", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def status(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + + @status.setter + def status(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "status", value) + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Time when the distribution was last updated + """ + return pulumi.get(self, "updated_at") + + @updated_at.setter + def updated_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "updated_at", value) + + +@pulumi.type_token("stackit:index/cdnDistribution:CdnDistribution") +class CdnDistribution(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + config: Optional[pulumi.Input[Union['CdnDistributionConfigArgs', 'CdnDistributionConfigArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['CdnDistributionConfigArgs', 'CdnDistributionConfigArgsDict']] config: The distribution configuration + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: CdnDistributionArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param CdnDistributionArgs 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(CdnDistributionArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + config: Optional[pulumi.Input[Union['CdnDistributionConfigArgs', 'CdnDistributionConfigArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = CdnDistributionArgs.__new__(CdnDistributionArgs) + + if config is None and not opts.urn: + raise TypeError("Missing required property 'config'") + __props__.__dict__["config"] = config + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["created_at"] = None + __props__.__dict__["distribution_id"] = None + __props__.__dict__["domains"] = None + __props__.__dict__["errors"] = None + __props__.__dict__["status"] = None + __props__.__dict__["updated_at"] = None + super(CdnDistribution, __self__).__init__( + 'stackit:index/cdnDistribution:CdnDistribution', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + config: Optional[pulumi.Input[Union['CdnDistributionConfigArgs', 'CdnDistributionConfigArgsDict']]] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + distribution_id: Optional[pulumi.Input[builtins.str]] = None, + domains: Optional[pulumi.Input[Sequence[pulumi.Input[Union['CdnDistributionDomainArgs', 'CdnDistributionDomainArgsDict']]]]] = None, + errors: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + status: Optional[pulumi.Input[builtins.str]] = None, + updated_at: Optional[pulumi.Input[builtins.str]] = None) -> 'CdnDistribution': + """ + Get an existing CdnDistribution 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[Union['CdnDistributionConfigArgs', 'CdnDistributionConfigArgsDict']] config: The distribution configuration + :param pulumi.Input[builtins.str] created_at: Time when the distribution was created + :param pulumi.Input[builtins.str] distribution_id: CDN distribution ID + :param pulumi.Input[Sequence[pulumi.Input[Union['CdnDistributionDomainArgs', 'CdnDistributionDomainArgsDict']]]] domains: List of configured domains for the distribution + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] errors: List of distribution errors + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the distribution + :param pulumi.Input[builtins.str] status: Status of the distribution + :param pulumi.Input[builtins.str] updated_at: Time when the distribution was last updated + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _CdnDistributionState.__new__(_CdnDistributionState) + + __props__.__dict__["config"] = config + __props__.__dict__["created_at"] = created_at + __props__.__dict__["distribution_id"] = distribution_id + __props__.__dict__["domains"] = domains + __props__.__dict__["errors"] = errors + __props__.__dict__["project_id"] = project_id + __props__.__dict__["status"] = status + __props__.__dict__["updated_at"] = updated_at + return CdnDistribution(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def config(self) -> pulumi.Output['outputs.CdnDistributionConfig']: + """ + The distribution configuration + """ + return pulumi.get(self, "config") + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> pulumi.Output[builtins.str]: + """ + Time when the distribution was created + """ + return pulumi.get(self, "created_at") + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> pulumi.Output[builtins.str]: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @property + @pulumi.getter + def domains(self) -> pulumi.Output[Sequence['outputs.CdnDistributionDomain']]: + """ + List of configured domains for the distribution + """ + return pulumi.get(self, "domains") + + @property + @pulumi.getter + def errors(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def status(self) -> pulumi.Output[builtins.str]: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> pulumi.Output[builtins.str]: + """ + Time when the distribution was last updated + """ + return pulumi.get(self, "updated_at") + diff --git a/sdk/python/pulumi_stackit/config/__init__.py b/sdk/python/pulumi_stackit/config/__init__.py new file mode 100644 index 0000000..76a596c --- /dev/null +++ b/sdk/python/pulumi_stackit/config/__init__.py @@ -0,0 +1,9 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import sys +from .vars import _ExportableConfig + +sys.modules[__name__].__class__ = _ExportableConfig diff --git a/sdk/python/pulumi_stackit/config/__init__.pyi b/sdk/python/pulumi_stackit/config/__init__.pyi new file mode 100644 index 0000000..ab1aa88 --- /dev/null +++ b/sdk/python/pulumi_stackit/config/__init__.pyi @@ -0,0 +1,208 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from .. import _utilities + +argusCustomEndpoint: Optional[str] +""" +Custom endpoint for the Argus service +""" + +authorizationCustomEndpoint: Optional[str] +""" +Custom endpoint for the Membership service +""" + +cdnCustomEndpoint: Optional[str] +""" +Custom endpoint for the CDN service +""" + +credentialsPath: Optional[str] +""" +Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default +value is `~/.stackit/credentials.json`. +""" + +defaultRegion: Optional[str] +""" +Region will be used as the default location for regional services. Not all services require a region, some are global +""" + +dnsCustomEndpoint: Optional[str] +""" +Custom endpoint for the DNS service +""" + +enableBetaResources: Optional[bool] +""" +Enable beta resources. Default is false. +""" + +experiments: Optional[str] +""" +Enables experiments. These are unstable features without official support. More information can be found in the README. +Available Experiments: [iam] +""" + +gitCustomEndpoint: Optional[str] +""" +Custom endpoint for the Git service +""" + +iaasCustomEndpoint: Optional[str] +""" +Custom endpoint for the IaaS service +""" + +loadbalancerCustomEndpoint: Optional[str] +""" +Custom endpoint for the Load Balancer service +""" + +logmeCustomEndpoint: Optional[str] +""" +Custom endpoint for the LogMe service +""" + +mariadbCustomEndpoint: Optional[str] +""" +Custom endpoint for the MariaDB service +""" + +modelservingCustomEndpoint: Optional[str] +""" +Custom endpoint for the AI Model Serving service +""" + +mongodbflexCustomEndpoint: Optional[str] +""" +Custom endpoint for the MongoDB Flex service +""" + +objectstorageCustomEndpoint: Optional[str] +""" +Custom endpoint for the Object Storage service +""" + +observabilityCustomEndpoint: Optional[str] +""" +Custom endpoint for the Observability service +""" + +opensearchCustomEndpoint: Optional[str] +""" +Custom endpoint for the OpenSearch service +""" + +postgresflexCustomEndpoint: Optional[str] +""" +Custom endpoint for the PostgresFlex service +""" + +privateKey: Optional[str] +""" +Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is +included in the service account key. +""" + +privateKeyPath: Optional[str] +""" +Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private +key that is included in the service account key. +""" + +rabbitmqCustomEndpoint: Optional[str] +""" +Custom endpoint for the RabbitMQ service +""" + +redisCustomEndpoint: Optional[str] +""" +Custom endpoint for the Redis service +""" + +region: Optional[str] +""" +Region will be used as the default location for regional services. Not all services require a region, some are global +""" + +resourcemanagerCustomEndpoint: Optional[str] +""" +Custom endpoint for the Resource Manager service +""" + +secretsmanagerCustomEndpoint: Optional[str] +""" +Custom endpoint for the Secrets Manager service +""" + +serverBackupCustomEndpoint: Optional[str] +""" +Custom endpoint for the Server Backup service +""" + +serverUpdateCustomEndpoint: Optional[str] +""" +Custom endpoint for the Server Update service +""" + +serviceAccountCustomEndpoint: Optional[str] +""" +Custom endpoint for the Service Account service +""" + +serviceAccountEmail: Optional[str] +""" +Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required +if you want to use the resource manager project resource. +""" + +serviceAccountKey: Optional[str] +""" +Service account key used for authentication. If set, the key flow will be used to authenticate all operations. +""" + +serviceAccountKeyPath: Optional[str] +""" +Path for the service account key used for authentication. If set, the key flow will be used to authenticate all +operations. +""" + +serviceAccountToken: Optional[str] +""" +Token used for authentication. If set, the token flow will be used to authenticate all operations. +""" + +serviceEnablementCustomEndpoint: Optional[str] +""" +Custom endpoint for the Service Enablement API +""" + +skeCustomEndpoint: Optional[str] +""" +Custom endpoint for the Kubernetes Engine (SKE) service +""" + +sqlserverflexCustomEndpoint: Optional[str] +""" +Custom endpoint for the SQL Server Flex service +""" + +tokenCustomEndpoint: Optional[str] +""" +Custom endpoint for the token API, which is used to request access tokens when using the key flow +""" + diff --git a/sdk/python/pulumi_stackit/config/vars.py b/sdk/python/pulumi_stackit/config/vars.py new file mode 100644 index 0000000..425114d --- /dev/null +++ b/sdk/python/pulumi_stackit/config/vars.py @@ -0,0 +1,288 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from .. import _utilities + +import types + +__config__ = pulumi.Config('stackit') + + +class _ExportableConfig(types.ModuleType): + @property + def argus_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Argus service + """ + return __config__.get('argusCustomEndpoint') + + @property + def authorization_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Membership service + """ + return __config__.get('authorizationCustomEndpoint') + + @property + def cdn_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the CDN service + """ + return __config__.get('cdnCustomEndpoint') + + @property + def credentials_path(self) -> Optional[str]: + """ + Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + value is `~/.stackit/credentials.json`. + """ + return __config__.get('credentialsPath') + + @property + def default_region(self) -> Optional[str]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return __config__.get('defaultRegion') + + @property + def dns_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the DNS service + """ + return __config__.get('dnsCustomEndpoint') + + @property + def enable_beta_resources(self) -> Optional[bool]: + """ + Enable beta resources. Default is false. + """ + return __config__.get_bool('enableBetaResources') + + @property + def experiments(self) -> Optional[str]: + """ + Enables experiments. These are unstable features without official support. More information can be found in the README. + Available Experiments: [iam] + """ + return __config__.get('experiments') + + @property + def git_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Git service + """ + return __config__.get('gitCustomEndpoint') + + @property + def iaas_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the IaaS service + """ + return __config__.get('iaasCustomEndpoint') + + @property + def loadbalancer_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Load Balancer service + """ + return __config__.get('loadbalancerCustomEndpoint') + + @property + def logme_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the LogMe service + """ + return __config__.get('logmeCustomEndpoint') + + @property + def mariadb_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the MariaDB service + """ + return __config__.get('mariadbCustomEndpoint') + + @property + def modelserving_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the AI Model Serving service + """ + return __config__.get('modelservingCustomEndpoint') + + @property + def mongodbflex_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the MongoDB Flex service + """ + return __config__.get('mongodbflexCustomEndpoint') + + @property + def objectstorage_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Object Storage service + """ + return __config__.get('objectstorageCustomEndpoint') + + @property + def observability_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Observability service + """ + return __config__.get('observabilityCustomEndpoint') + + @property + def opensearch_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the OpenSearch service + """ + return __config__.get('opensearchCustomEndpoint') + + @property + def postgresflex_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the PostgresFlex service + """ + return __config__.get('postgresflexCustomEndpoint') + + @property + def private_key(self) -> Optional[str]: + """ + Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + included in the service account key. + """ + return __config__.get('privateKey') + + @property + def private_key_path(self) -> Optional[str]: + """ + Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + key that is included in the service account key. + """ + return __config__.get('privateKeyPath') + + @property + def rabbitmq_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the RabbitMQ service + """ + return __config__.get('rabbitmqCustomEndpoint') + + @property + def redis_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Redis service + """ + return __config__.get('redisCustomEndpoint') + + @property + def region(self) -> Optional[str]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return __config__.get('region') + + @property + def resourcemanager_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Resource Manager service + """ + return __config__.get('resourcemanagerCustomEndpoint') + + @property + def secretsmanager_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Secrets Manager service + """ + return __config__.get('secretsmanagerCustomEndpoint') + + @property + def server_backup_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Server Backup service + """ + return __config__.get('serverBackupCustomEndpoint') + + @property + def server_update_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Server Update service + """ + return __config__.get('serverUpdateCustomEndpoint') + + @property + def service_account_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Service Account service + """ + return __config__.get('serviceAccountCustomEndpoint') + + @property + def service_account_email(self) -> Optional[str]: + """ + Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + if you want to use the resource manager project resource. + """ + return __config__.get('serviceAccountEmail') + + @property + def service_account_key(self) -> Optional[str]: + """ + Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + """ + return __config__.get('serviceAccountKey') + + @property + def service_account_key_path(self) -> Optional[str]: + """ + Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + operations. + """ + return __config__.get('serviceAccountKeyPath') + + @property + def service_account_token(self) -> Optional[str]: + """ + Token used for authentication. If set, the token flow will be used to authenticate all operations. + """ + return __config__.get('serviceAccountToken') + + @property + def service_enablement_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Service Enablement API + """ + return __config__.get('serviceEnablementCustomEndpoint') + + @property + def ske_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the Kubernetes Engine (SKE) service + """ + return __config__.get('skeCustomEndpoint') + + @property + def sqlserverflex_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the SQL Server Flex service + """ + return __config__.get('sqlserverflexCustomEndpoint') + + @property + def token_custom_endpoint(self) -> Optional[str]: + """ + Custom endpoint for the token API, which is used to request access tokens when using the key flow + """ + return __config__.get('tokenCustomEndpoint') + diff --git a/sdk/python/pulumi_stackit/dns_record_set.py b/sdk/python/pulumi_stackit/dns_record_set.py new file mode 100644 index 0000000..9f067f1 --- /dev/null +++ b/sdk/python/pulumi_stackit/dns_record_set.py @@ -0,0 +1,601 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['DnsRecordSetArgs', 'DnsRecordSet'] + +@pulumi.input_type +class DnsRecordSetArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + records: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + type: pulumi.Input[builtins.str], + zone_id: pulumi.Input[builtins.str], + active: Optional[pulumi.Input[builtins.bool]] = None, + comment: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + ttl: Optional[pulumi.Input[builtins.int]] = None): + """ + The set of arguments for constructing a DnsRecordSet resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns record set is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] records: Records. + :param pulumi.Input[builtins.str] type: The record set type. E.g. `A` or `CNAME` + :param pulumi.Input[builtins.str] zone_id: The zone ID to which is dns record set is associated. + :param pulumi.Input[builtins.bool] active: Specifies if the record set is active or not. Defaults to `true` + :param pulumi.Input[builtins.str] comment: Comment. + :param pulumi.Input[builtins.str] name: Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + :param pulumi.Input[builtins.int] ttl: Time to live. E.g. 3600 + """ + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "records", records) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "zone_id", zone_id) + if active is not None: + pulumi.set(__self__, "active", active) + if comment is not None: + pulumi.set(__self__, "comment", comment) + if name is not None: + pulumi.set(__self__, "name", name) + if ttl is not None: + pulumi.set(__self__, "ttl", ttl) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the dns record set is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def records(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Records. + """ + return pulumi.get(self, "records") + + @records.setter + def records(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "records", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[builtins.str]: + """ + The record set type. E.g. `A` or `CNAME` + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> pulumi.Input[builtins.str]: + """ + The zone ID to which is dns record set is associated. + """ + return pulumi.get(self, "zone_id") + + @zone_id.setter + def zone_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "zone_id", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies if the record set is active or not. Defaults to `true` + """ + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter + def comment(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comment. + """ + return pulumi.get(self, "comment") + + @comment.setter + def comment(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "comment", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def ttl(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Time to live. E.g. 3600 + """ + return pulumi.get(self, "ttl") + + @ttl.setter + def ttl(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl", value) + + +@pulumi.input_type +class _DnsRecordSetState: + def __init__(__self__, *, + active: Optional[pulumi.Input[builtins.bool]] = None, + comment: Optional[pulumi.Input[builtins.str]] = None, + error: Optional[pulumi.Input[builtins.str]] = None, + fqdn: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + record_set_id: Optional[pulumi.Input[builtins.str]] = None, + records: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + ttl: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering DnsRecordSet resources. + :param pulumi.Input[builtins.bool] active: Specifies if the record set is active or not. Defaults to `true` + :param pulumi.Input[builtins.str] comment: Comment. + :param pulumi.Input[builtins.str] error: Error shows error in case create/update/delete failed. + :param pulumi.Input[builtins.str] fqdn: Fully qualified domain name (FQDN) of the record set. + :param pulumi.Input[builtins.str] name: Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns record set is associated. + :param pulumi.Input[builtins.str] record_set_id: The rr set id. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] records: Records. + :param pulumi.Input[builtins.str] state: Record set state. + :param pulumi.Input[builtins.int] ttl: Time to live. E.g. 3600 + :param pulumi.Input[builtins.str] type: The record set type. E.g. `A` or `CNAME` + :param pulumi.Input[builtins.str] zone_id: The zone ID to which is dns record set is associated. + """ + if active is not None: + pulumi.set(__self__, "active", active) + if comment is not None: + pulumi.set(__self__, "comment", comment) + if error is not None: + pulumi.set(__self__, "error", error) + if fqdn is not None: + pulumi.set(__self__, "fqdn", fqdn) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if record_set_id is not None: + pulumi.set(__self__, "record_set_id", record_set_id) + if records is not None: + pulumi.set(__self__, "records", records) + if state is not None: + pulumi.set(__self__, "state", state) + if ttl is not None: + pulumi.set(__self__, "ttl", ttl) + if type is not None: + pulumi.set(__self__, "type", type) + if zone_id is not None: + pulumi.set(__self__, "zone_id", zone_id) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies if the record set is active or not. Defaults to `true` + """ + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter + def comment(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Comment. + """ + return pulumi.get(self, "comment") + + @comment.setter + def comment(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "comment", value) + + @property + @pulumi.getter + def error(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Error shows error in case create/update/delete failed. + """ + return pulumi.get(self, "error") + + @error.setter + def error(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "error", value) + + @property + @pulumi.getter + def fqdn(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Fully qualified domain name (FQDN) of the record set. + """ + return pulumi.get(self, "fqdn") + + @fqdn.setter + def fqdn(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fqdn", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the dns record set is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="recordSetId") + def record_set_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The rr set id. + """ + return pulumi.get(self, "record_set_id") + + @record_set_id.setter + def record_set_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "record_set_id", value) + + @property + @pulumi.getter + def records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Records. + """ + return pulumi.get(self, "records") + + @records.setter + def records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "records", value) + + @property + @pulumi.getter + def state(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Record set state. + """ + return pulumi.get(self, "state") + + @state.setter + def state(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "state", value) + + @property + @pulumi.getter + def ttl(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Time to live. E.g. 3600 + """ + return pulumi.get(self, "ttl") + + @ttl.setter + def ttl(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The record set type. E.g. `A` or `CNAME` + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The zone ID to which is dns record set is associated. + """ + return pulumi.get(self, "zone_id") + + @zone_id.setter + def zone_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "zone_id", value) + + +@pulumi.type_token("stackit:index/dnsRecordSet:DnsRecordSet") +class DnsRecordSet(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + comment: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + records: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ttl: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + DNS Record Set Resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.bool] active: Specifies if the record set is active or not. Defaults to `true` + :param pulumi.Input[builtins.str] comment: Comment. + :param pulumi.Input[builtins.str] name: Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns record set is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] records: Records. + :param pulumi.Input[builtins.int] ttl: Time to live. E.g. 3600 + :param pulumi.Input[builtins.str] type: The record set type. E.g. `A` or `CNAME` + :param pulumi.Input[builtins.str] zone_id: The zone ID to which is dns record set is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DnsRecordSetArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + DNS Record Set Resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param DnsRecordSetArgs 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(DnsRecordSetArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + comment: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + records: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ttl: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.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__ = DnsRecordSetArgs.__new__(DnsRecordSetArgs) + + __props__.__dict__["active"] = active + __props__.__dict__["comment"] = comment + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if records is None and not opts.urn: + raise TypeError("Missing required property 'records'") + __props__.__dict__["records"] = records + __props__.__dict__["ttl"] = ttl + if type is None and not opts.urn: + raise TypeError("Missing required property 'type'") + __props__.__dict__["type"] = type + if zone_id is None and not opts.urn: + raise TypeError("Missing required property 'zone_id'") + __props__.__dict__["zone_id"] = zone_id + __props__.__dict__["error"] = None + __props__.__dict__["fqdn"] = None + __props__.__dict__["record_set_id"] = None + __props__.__dict__["state"] = None + super(DnsRecordSet, __self__).__init__( + 'stackit:index/dnsRecordSet:DnsRecordSet', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + comment: Optional[pulumi.Input[builtins.str]] = None, + error: Optional[pulumi.Input[builtins.str]] = None, + fqdn: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + record_set_id: Optional[pulumi.Input[builtins.str]] = None, + records: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + ttl: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None) -> 'DnsRecordSet': + """ + Get an existing DnsRecordSet 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[builtins.bool] active: Specifies if the record set is active or not. Defaults to `true` + :param pulumi.Input[builtins.str] comment: Comment. + :param pulumi.Input[builtins.str] error: Error shows error in case create/update/delete failed. + :param pulumi.Input[builtins.str] fqdn: Fully qualified domain name (FQDN) of the record set. + :param pulumi.Input[builtins.str] name: Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns record set is associated. + :param pulumi.Input[builtins.str] record_set_id: The rr set id. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] records: Records. + :param pulumi.Input[builtins.str] state: Record set state. + :param pulumi.Input[builtins.int] ttl: Time to live. E.g. 3600 + :param pulumi.Input[builtins.str] type: The record set type. E.g. `A` or `CNAME` + :param pulumi.Input[builtins.str] zone_id: The zone ID to which is dns record set is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DnsRecordSetState.__new__(_DnsRecordSetState) + + __props__.__dict__["active"] = active + __props__.__dict__["comment"] = comment + __props__.__dict__["error"] = error + __props__.__dict__["fqdn"] = fqdn + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["record_set_id"] = record_set_id + __props__.__dict__["records"] = records + __props__.__dict__["state"] = state + __props__.__dict__["ttl"] = ttl + __props__.__dict__["type"] = type + __props__.__dict__["zone_id"] = zone_id + return DnsRecordSet(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def active(self) -> pulumi.Output[builtins.bool]: + """ + Specifies if the record set is active or not. Defaults to `true` + """ + return pulumi.get(self, "active") + + @property + @pulumi.getter + def comment(self) -> pulumi.Output[builtins.str]: + """ + Comment. + """ + return pulumi.get(self, "comment") + + @property + @pulumi.getter + def error(self) -> pulumi.Output[builtins.str]: + """ + Error shows error in case create/update/delete failed. + """ + return pulumi.get(self, "error") + + @property + @pulumi.getter + def fqdn(self) -> pulumi.Output[builtins.str]: + """ + Fully qualified domain name (FQDN) of the record set. + """ + return pulumi.get(self, "fqdn") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the dns record set is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="recordSetId") + def record_set_id(self) -> pulumi.Output[builtins.str]: + """ + The rr set id. + """ + return pulumi.get(self, "record_set_id") + + @property + @pulumi.getter + def records(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + Records. + """ + return pulumi.get(self, "records") + + @property + @pulumi.getter + def state(self) -> pulumi.Output[builtins.str]: + """ + Record set state. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def ttl(self) -> pulumi.Output[builtins.int]: + """ + Time to live. E.g. 3600 + """ + return pulumi.get(self, "ttl") + + @property + @pulumi.getter + def type(self) -> pulumi.Output[builtins.str]: + """ + The record set type. E.g. `A` or `CNAME` + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> pulumi.Output[builtins.str]: + """ + The zone ID to which is dns record set is associated. + """ + return pulumi.get(self, "zone_id") + diff --git a/sdk/python/pulumi_stackit/dns_zone.py b/sdk/python/pulumi_stackit/dns_zone.py new file mode 100644 index 0000000..dc1641e --- /dev/null +++ b/sdk/python/pulumi_stackit/dns_zone.py @@ -0,0 +1,971 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['DnsZoneArgs', 'DnsZone'] + +@pulumi.input_type +class DnsZoneArgs: + def __init__(__self__, *, + dns_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + acl: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + contact_email: Optional[pulumi.Input[builtins.str]] = None, + default_ttl: Optional[pulumi.Input[builtins.int]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + expire_time: Optional[pulumi.Input[builtins.int]] = None, + is_reverse_zone: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + negative_cache: Optional[pulumi.Input[builtins.int]] = None, + primaries: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + refresh_time: Optional[pulumi.Input[builtins.int]] = None, + retry_time: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a DnsZone resource. + :param pulumi.Input[builtins.str] dns_name: The zone name. E.g. `example.com` + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns zone is associated. + :param pulumi.Input[builtins.str] acl: The access control list. E.g. `0.0.0.0/0,::/0` + :param pulumi.Input[builtins.str] contact_email: A contact e-mail for the zone. + :param pulumi.Input[builtins.int] default_ttl: Default time to live. E.g. 3600. + :param pulumi.Input[builtins.str] description: Description of the zone. + :param pulumi.Input[builtins.int] expire_time: Expire time. E.g. 1209600. + :param pulumi.Input[builtins.bool] is_reverse_zone: Specifies, if the zone is a reverse zone or not. Defaults to `false` + :param pulumi.Input[builtins.str] name: The user given name of the zone. + :param pulumi.Input[builtins.int] negative_cache: Negative caching. E.g. 60 + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] primaries: Primary name server for secondary zone. E.g. ["1.2.3.4"] + :param pulumi.Input[builtins.int] refresh_time: Refresh time. E.g. 3600 + :param pulumi.Input[builtins.int] retry_time: Retry time. E.g. 600 + :param pulumi.Input[builtins.str] type: Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + """ + pulumi.set(__self__, "dns_name", dns_name) + pulumi.set(__self__, "project_id", project_id) + if acl is not None: + pulumi.set(__self__, "acl", acl) + if active is not None: + pulumi.set(__self__, "active", active) + if contact_email is not None: + pulumi.set(__self__, "contact_email", contact_email) + if default_ttl is not None: + pulumi.set(__self__, "default_ttl", default_ttl) + if description is not None: + pulumi.set(__self__, "description", description) + if expire_time is not None: + pulumi.set(__self__, "expire_time", expire_time) + if is_reverse_zone is not None: + pulumi.set(__self__, "is_reverse_zone", is_reverse_zone) + if name is not None: + pulumi.set(__self__, "name", name) + if negative_cache is not None: + pulumi.set(__self__, "negative_cache", negative_cache) + if primaries is not None: + pulumi.set(__self__, "primaries", primaries) + if refresh_time is not None: + pulumi.set(__self__, "refresh_time", refresh_time) + if retry_time is not None: + pulumi.set(__self__, "retry_time", retry_time) + if type is not None: + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter(name="dnsName") + def dns_name(self) -> pulumi.Input[builtins.str]: + """ + The zone name. E.g. `example.com` + """ + return pulumi.get(self, "dns_name") + + @dns_name.setter + def dns_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "dns_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the dns zone is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The access control list. E.g. `0.0.0.0/0,::/0` + """ + return pulumi.get(self, "acl") + + @acl.setter + def acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "acl", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[builtins.bool]]: + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter(name="contactEmail") + def contact_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + A contact e-mail for the zone. + """ + return pulumi.get(self, "contact_email") + + @contact_email.setter + def contact_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "contact_email", value) + + @property + @pulumi.getter(name="defaultTtl") + def default_ttl(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Default time to live. E.g. 3600. + """ + return pulumi.get(self, "default_ttl") + + @default_ttl.setter + def default_ttl(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "default_ttl", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Description of the zone. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="expireTime") + def expire_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Expire time. E.g. 1209600. + """ + return pulumi.get(self, "expire_time") + + @expire_time.setter + def expire_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "expire_time", value) + + @property + @pulumi.getter(name="isReverseZone") + def is_reverse_zone(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies, if the zone is a reverse zone or not. Defaults to `false` + """ + return pulumi.get(self, "is_reverse_zone") + + @is_reverse_zone.setter + def is_reverse_zone(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "is_reverse_zone", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The user given name of the zone. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="negativeCache") + def negative_cache(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Negative caching. E.g. 60 + """ + return pulumi.get(self, "negative_cache") + + @negative_cache.setter + def negative_cache(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "negative_cache", value) + + @property + @pulumi.getter + def primaries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Primary name server for secondary zone. E.g. ["1.2.3.4"] + """ + return pulumi.get(self, "primaries") + + @primaries.setter + def primaries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "primaries", value) + + @property + @pulumi.getter(name="refreshTime") + def refresh_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Refresh time. E.g. 3600 + """ + return pulumi.get(self, "refresh_time") + + @refresh_time.setter + def refresh_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "refresh_time", value) + + @property + @pulumi.getter(name="retryTime") + def retry_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Retry time. E.g. 600 + """ + return pulumi.get(self, "retry_time") + + @retry_time.setter + def retry_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "retry_time", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "type", value) + + +@pulumi.input_type +class _DnsZoneState: + def __init__(__self__, *, + acl: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + contact_email: Optional[pulumi.Input[builtins.str]] = None, + default_ttl: Optional[pulumi.Input[builtins.int]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + dns_name: Optional[pulumi.Input[builtins.str]] = None, + expire_time: Optional[pulumi.Input[builtins.int]] = None, + is_reverse_zone: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + negative_cache: Optional[pulumi.Input[builtins.int]] = None, + primaries: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + primary_name_server: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + record_count: Optional[pulumi.Input[builtins.int]] = None, + refresh_time: Optional[pulumi.Input[builtins.int]] = None, + retry_time: Optional[pulumi.Input[builtins.int]] = None, + serial_number: Optional[pulumi.Input[builtins.int]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + visibility: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering DnsZone resources. + :param pulumi.Input[builtins.str] acl: The access control list. E.g. `0.0.0.0/0,::/0` + :param pulumi.Input[builtins.str] contact_email: A contact e-mail for the zone. + :param pulumi.Input[builtins.int] default_ttl: Default time to live. E.g. 3600. + :param pulumi.Input[builtins.str] description: Description of the zone. + :param pulumi.Input[builtins.str] dns_name: The zone name. E.g. `example.com` + :param pulumi.Input[builtins.int] expire_time: Expire time. E.g. 1209600. + :param pulumi.Input[builtins.bool] is_reverse_zone: Specifies, if the zone is a reverse zone or not. Defaults to `false` + :param pulumi.Input[builtins.str] name: The user given name of the zone. + :param pulumi.Input[builtins.int] negative_cache: Negative caching. E.g. 60 + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] primaries: Primary name server for secondary zone. E.g. ["1.2.3.4"] + :param pulumi.Input[builtins.str] primary_name_server: Primary name server. FQDN. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns zone is associated. + :param pulumi.Input[builtins.int] record_count: Record count how many records are in the zone. + :param pulumi.Input[builtins.int] refresh_time: Refresh time. E.g. 3600 + :param pulumi.Input[builtins.int] retry_time: Retry time. E.g. 600 + :param pulumi.Input[builtins.int] serial_number: Serial number. E.g. `2022111400`. + :param pulumi.Input[builtins.str] state: Zone state. E.g. `CREATE_SUCCEEDED`. + :param pulumi.Input[builtins.str] type: Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + :param pulumi.Input[builtins.str] visibility: Visibility of the zone. E.g. `public`. + :param pulumi.Input[builtins.str] zone_id: The zone ID. + """ + if acl is not None: + pulumi.set(__self__, "acl", acl) + if active is not None: + pulumi.set(__self__, "active", active) + if contact_email is not None: + pulumi.set(__self__, "contact_email", contact_email) + if default_ttl is not None: + pulumi.set(__self__, "default_ttl", default_ttl) + if description is not None: + pulumi.set(__self__, "description", description) + if dns_name is not None: + pulumi.set(__self__, "dns_name", dns_name) + if expire_time is not None: + pulumi.set(__self__, "expire_time", expire_time) + if is_reverse_zone is not None: + pulumi.set(__self__, "is_reverse_zone", is_reverse_zone) + if name is not None: + pulumi.set(__self__, "name", name) + if negative_cache is not None: + pulumi.set(__self__, "negative_cache", negative_cache) + if primaries is not None: + pulumi.set(__self__, "primaries", primaries) + if primary_name_server is not None: + pulumi.set(__self__, "primary_name_server", primary_name_server) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if record_count is not None: + pulumi.set(__self__, "record_count", record_count) + if refresh_time is not None: + pulumi.set(__self__, "refresh_time", refresh_time) + if retry_time is not None: + pulumi.set(__self__, "retry_time", retry_time) + if serial_number is not None: + pulumi.set(__self__, "serial_number", serial_number) + if state is not None: + pulumi.set(__self__, "state", state) + if type is not None: + pulumi.set(__self__, "type", type) + if visibility is not None: + pulumi.set(__self__, "visibility", visibility) + if zone_id is not None: + pulumi.set(__self__, "zone_id", zone_id) + + @property + @pulumi.getter + def acl(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The access control list. E.g. `0.0.0.0/0,::/0` + """ + return pulumi.get(self, "acl") + + @acl.setter + def acl(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "acl", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[builtins.bool]]: + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter(name="contactEmail") + def contact_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + A contact e-mail for the zone. + """ + return pulumi.get(self, "contact_email") + + @contact_email.setter + def contact_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "contact_email", value) + + @property + @pulumi.getter(name="defaultTtl") + def default_ttl(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Default time to live. E.g. 3600. + """ + return pulumi.get(self, "default_ttl") + + @default_ttl.setter + def default_ttl(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "default_ttl", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Description of the zone. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="dnsName") + def dns_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The zone name. E.g. `example.com` + """ + return pulumi.get(self, "dns_name") + + @dns_name.setter + def dns_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dns_name", value) + + @property + @pulumi.getter(name="expireTime") + def expire_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Expire time. E.g. 1209600. + """ + return pulumi.get(self, "expire_time") + + @expire_time.setter + def expire_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "expire_time", value) + + @property + @pulumi.getter(name="isReverseZone") + def is_reverse_zone(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies, if the zone is a reverse zone or not. Defaults to `false` + """ + return pulumi.get(self, "is_reverse_zone") + + @is_reverse_zone.setter + def is_reverse_zone(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "is_reverse_zone", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The user given name of the zone. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="negativeCache") + def negative_cache(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Negative caching. E.g. 60 + """ + return pulumi.get(self, "negative_cache") + + @negative_cache.setter + def negative_cache(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "negative_cache", value) + + @property + @pulumi.getter + def primaries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Primary name server for secondary zone. E.g. ["1.2.3.4"] + """ + return pulumi.get(self, "primaries") + + @primaries.setter + def primaries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "primaries", value) + + @property + @pulumi.getter(name="primaryNameServer") + def primary_name_server(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Primary name server. FQDN. + """ + return pulumi.get(self, "primary_name_server") + + @primary_name_server.setter + def primary_name_server(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "primary_name_server", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the dns zone is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="recordCount") + def record_count(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Record count how many records are in the zone. + """ + return pulumi.get(self, "record_count") + + @record_count.setter + def record_count(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "record_count", value) + + @property + @pulumi.getter(name="refreshTime") + def refresh_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Refresh time. E.g. 3600 + """ + return pulumi.get(self, "refresh_time") + + @refresh_time.setter + def refresh_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "refresh_time", value) + + @property + @pulumi.getter(name="retryTime") + def retry_time(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Retry time. E.g. 600 + """ + return pulumi.get(self, "retry_time") + + @retry_time.setter + def retry_time(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "retry_time", value) + + @property + @pulumi.getter(name="serialNumber") + def serial_number(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Serial number. E.g. `2022111400`. + """ + return pulumi.get(self, "serial_number") + + @serial_number.setter + def serial_number(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "serial_number", value) + + @property + @pulumi.getter + def state(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Zone state. E.g. `CREATE_SUCCEEDED`. + """ + return pulumi.get(self, "state") + + @state.setter + def state(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "state", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def visibility(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Visibility of the zone. E.g. `public`. + """ + return pulumi.get(self, "visibility") + + @visibility.setter + def visibility(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "visibility", value) + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The zone ID. + """ + return pulumi.get(self, "zone_id") + + @zone_id.setter + def zone_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "zone_id", value) + + +@pulumi.type_token("stackit:index/dnsZone:DnsZone") +class DnsZone(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acl: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + contact_email: Optional[pulumi.Input[builtins.str]] = None, + default_ttl: Optional[pulumi.Input[builtins.int]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + dns_name: Optional[pulumi.Input[builtins.str]] = None, + expire_time: Optional[pulumi.Input[builtins.int]] = None, + is_reverse_zone: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + negative_cache: Optional[pulumi.Input[builtins.int]] = None, + primaries: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh_time: Optional[pulumi.Input[builtins.int]] = None, + retry_time: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + DNS Zone resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] acl: The access control list. E.g. `0.0.0.0/0,::/0` + :param pulumi.Input[builtins.str] contact_email: A contact e-mail for the zone. + :param pulumi.Input[builtins.int] default_ttl: Default time to live. E.g. 3600. + :param pulumi.Input[builtins.str] description: Description of the zone. + :param pulumi.Input[builtins.str] dns_name: The zone name. E.g. `example.com` + :param pulumi.Input[builtins.int] expire_time: Expire time. E.g. 1209600. + :param pulumi.Input[builtins.bool] is_reverse_zone: Specifies, if the zone is a reverse zone or not. Defaults to `false` + :param pulumi.Input[builtins.str] name: The user given name of the zone. + :param pulumi.Input[builtins.int] negative_cache: Negative caching. E.g. 60 + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] primaries: Primary name server for secondary zone. E.g. ["1.2.3.4"] + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns zone is associated. + :param pulumi.Input[builtins.int] refresh_time: Refresh time. E.g. 3600 + :param pulumi.Input[builtins.int] retry_time: Retry time. E.g. 600 + :param pulumi.Input[builtins.str] type: Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DnsZoneArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + DNS Zone resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param DnsZoneArgs 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(DnsZoneArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acl: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + contact_email: Optional[pulumi.Input[builtins.str]] = None, + default_ttl: Optional[pulumi.Input[builtins.int]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + dns_name: Optional[pulumi.Input[builtins.str]] = None, + expire_time: Optional[pulumi.Input[builtins.int]] = None, + is_reverse_zone: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + negative_cache: Optional[pulumi.Input[builtins.int]] = None, + primaries: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh_time: Optional[pulumi.Input[builtins.int]] = None, + retry_time: Optional[pulumi.Input[builtins.int]] = None, + type: Optional[pulumi.Input[builtins.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__ = DnsZoneArgs.__new__(DnsZoneArgs) + + __props__.__dict__["acl"] = acl + __props__.__dict__["active"] = active + __props__.__dict__["contact_email"] = contact_email + __props__.__dict__["default_ttl"] = default_ttl + __props__.__dict__["description"] = description + if dns_name is None and not opts.urn: + raise TypeError("Missing required property 'dns_name'") + __props__.__dict__["dns_name"] = dns_name + __props__.__dict__["expire_time"] = expire_time + __props__.__dict__["is_reverse_zone"] = is_reverse_zone + __props__.__dict__["name"] = name + __props__.__dict__["negative_cache"] = negative_cache + __props__.__dict__["primaries"] = primaries + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["refresh_time"] = refresh_time + __props__.__dict__["retry_time"] = retry_time + __props__.__dict__["type"] = type + __props__.__dict__["primary_name_server"] = None + __props__.__dict__["record_count"] = None + __props__.__dict__["serial_number"] = None + __props__.__dict__["state"] = None + __props__.__dict__["visibility"] = None + __props__.__dict__["zone_id"] = None + super(DnsZone, __self__).__init__( + 'stackit:index/dnsZone:DnsZone', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acl: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + contact_email: Optional[pulumi.Input[builtins.str]] = None, + default_ttl: Optional[pulumi.Input[builtins.int]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + dns_name: Optional[pulumi.Input[builtins.str]] = None, + expire_time: Optional[pulumi.Input[builtins.int]] = None, + is_reverse_zone: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + negative_cache: Optional[pulumi.Input[builtins.int]] = None, + primaries: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + primary_name_server: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + record_count: Optional[pulumi.Input[builtins.int]] = None, + refresh_time: Optional[pulumi.Input[builtins.int]] = None, + retry_time: Optional[pulumi.Input[builtins.int]] = None, + serial_number: Optional[pulumi.Input[builtins.int]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + type: Optional[pulumi.Input[builtins.str]] = None, + visibility: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None) -> 'DnsZone': + """ + Get an existing DnsZone 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[builtins.str] acl: The access control list. E.g. `0.0.0.0/0,::/0` + :param pulumi.Input[builtins.str] contact_email: A contact e-mail for the zone. + :param pulumi.Input[builtins.int] default_ttl: Default time to live. E.g. 3600. + :param pulumi.Input[builtins.str] description: Description of the zone. + :param pulumi.Input[builtins.str] dns_name: The zone name. E.g. `example.com` + :param pulumi.Input[builtins.int] expire_time: Expire time. E.g. 1209600. + :param pulumi.Input[builtins.bool] is_reverse_zone: Specifies, if the zone is a reverse zone or not. Defaults to `false` + :param pulumi.Input[builtins.str] name: The user given name of the zone. + :param pulumi.Input[builtins.int] negative_cache: Negative caching. E.g. 60 + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] primaries: Primary name server for secondary zone. E.g. ["1.2.3.4"] + :param pulumi.Input[builtins.str] primary_name_server: Primary name server. FQDN. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the dns zone is associated. + :param pulumi.Input[builtins.int] record_count: Record count how many records are in the zone. + :param pulumi.Input[builtins.int] refresh_time: Refresh time. E.g. 3600 + :param pulumi.Input[builtins.int] retry_time: Retry time. E.g. 600 + :param pulumi.Input[builtins.int] serial_number: Serial number. E.g. `2022111400`. + :param pulumi.Input[builtins.str] state: Zone state. E.g. `CREATE_SUCCEEDED`. + :param pulumi.Input[builtins.str] type: Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + :param pulumi.Input[builtins.str] visibility: Visibility of the zone. E.g. `public`. + :param pulumi.Input[builtins.str] zone_id: The zone ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DnsZoneState.__new__(_DnsZoneState) + + __props__.__dict__["acl"] = acl + __props__.__dict__["active"] = active + __props__.__dict__["contact_email"] = contact_email + __props__.__dict__["default_ttl"] = default_ttl + __props__.__dict__["description"] = description + __props__.__dict__["dns_name"] = dns_name + __props__.__dict__["expire_time"] = expire_time + __props__.__dict__["is_reverse_zone"] = is_reverse_zone + __props__.__dict__["name"] = name + __props__.__dict__["negative_cache"] = negative_cache + __props__.__dict__["primaries"] = primaries + __props__.__dict__["primary_name_server"] = primary_name_server + __props__.__dict__["project_id"] = project_id + __props__.__dict__["record_count"] = record_count + __props__.__dict__["refresh_time"] = refresh_time + __props__.__dict__["retry_time"] = retry_time + __props__.__dict__["serial_number"] = serial_number + __props__.__dict__["state"] = state + __props__.__dict__["type"] = type + __props__.__dict__["visibility"] = visibility + __props__.__dict__["zone_id"] = zone_id + return DnsZone(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acl(self) -> pulumi.Output[builtins.str]: + """ + The access control list. E.g. `0.0.0.0/0,::/0` + """ + return pulumi.get(self, "acl") + + @property + @pulumi.getter + def active(self) -> pulumi.Output[builtins.bool]: + return pulumi.get(self, "active") + + @property + @pulumi.getter(name="contactEmail") + def contact_email(self) -> pulumi.Output[builtins.str]: + """ + A contact e-mail for the zone. + """ + return pulumi.get(self, "contact_email") + + @property + @pulumi.getter(name="defaultTtl") + def default_ttl(self) -> pulumi.Output[builtins.int]: + """ + Default time to live. E.g. 3600. + """ + return pulumi.get(self, "default_ttl") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[builtins.str]: + """ + Description of the zone. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="dnsName") + def dns_name(self) -> pulumi.Output[builtins.str]: + """ + The zone name. E.g. `example.com` + """ + return pulumi.get(self, "dns_name") + + @property + @pulumi.getter(name="expireTime") + def expire_time(self) -> pulumi.Output[builtins.int]: + """ + Expire time. E.g. 1209600. + """ + return pulumi.get(self, "expire_time") + + @property + @pulumi.getter(name="isReverseZone") + def is_reverse_zone(self) -> pulumi.Output[builtins.bool]: + """ + Specifies, if the zone is a reverse zone or not. Defaults to `false` + """ + return pulumi.get(self, "is_reverse_zone") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The user given name of the zone. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="negativeCache") + def negative_cache(self) -> pulumi.Output[builtins.int]: + """ + Negative caching. E.g. 60 + """ + return pulumi.get(self, "negative_cache") + + @property + @pulumi.getter + def primaries(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + Primary name server for secondary zone. E.g. ["1.2.3.4"] + """ + return pulumi.get(self, "primaries") + + @property + @pulumi.getter(name="primaryNameServer") + def primary_name_server(self) -> pulumi.Output[builtins.str]: + """ + Primary name server. FQDN. + """ + return pulumi.get(self, "primary_name_server") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the dns zone is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="recordCount") + def record_count(self) -> pulumi.Output[builtins.int]: + """ + Record count how many records are in the zone. + """ + return pulumi.get(self, "record_count") + + @property + @pulumi.getter(name="refreshTime") + def refresh_time(self) -> pulumi.Output[builtins.int]: + """ + Refresh time. E.g. 3600 + """ + return pulumi.get(self, "refresh_time") + + @property + @pulumi.getter(name="retryTime") + def retry_time(self) -> pulumi.Output[builtins.int]: + """ + Retry time. E.g. 600 + """ + return pulumi.get(self, "retry_time") + + @property + @pulumi.getter(name="serialNumber") + def serial_number(self) -> pulumi.Output[builtins.int]: + """ + Serial number. E.g. `2022111400`. + """ + return pulumi.get(self, "serial_number") + + @property + @pulumi.getter + def state(self) -> pulumi.Output[builtins.str]: + """ + Zone state. E.g. `CREATE_SUCCEEDED`. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def type(self) -> pulumi.Output[builtins.str]: + """ + Zone type. Defaults to `primary`. Supported values are: `primary`, `secondary`. + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter + def visibility(self) -> pulumi.Output[builtins.str]: + """ + Visibility of the zone. E.g. `public`. + """ + return pulumi.get(self, "visibility") + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> pulumi.Output[builtins.str]: + """ + The zone ID. + """ + return pulumi.get(self, "zone_id") + diff --git a/sdk/python/pulumi_stackit/get_affinity_group.py b/sdk/python/pulumi_stackit/get_affinity_group.py new file mode 100644 index 0000000..0d05f56 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_affinity_group.py @@ -0,0 +1,158 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetAffinityGroupResult', + 'AwaitableGetAffinityGroupResult', + 'get_affinity_group', + 'get_affinity_group_output', +] + +@pulumi.output_type +class GetAffinityGroupResult: + """ + A collection of values returned by getAffinityGroup. + """ + def __init__(__self__, affinity_group_id=None, id=None, members=None, name=None, policy=None, project_id=None): + if affinity_group_id and not isinstance(affinity_group_id, str): + raise TypeError("Expected argument 'affinity_group_id' to be a str") + pulumi.set(__self__, "affinity_group_id", affinity_group_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if members and not isinstance(members, list): + raise TypeError("Expected argument 'members' to be a list") + pulumi.set(__self__, "members", members) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if policy and not isinstance(policy, str): + raise TypeError("Expected argument 'policy' to be a str") + pulumi.set(__self__, "policy", policy) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="affinityGroupId") + def affinity_group_id(self) -> builtins.str: + """ + The affinity group ID. + """ + return pulumi.get(self, "affinity_group_id") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def members(self) -> Sequence[builtins.str]: + """ + Affinity Group schema. Must have a `region` specified in the provider configuration. + """ + return pulumi.get(self, "members") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the affinity group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def policy(self) -> builtins.str: + """ + The policy of the affinity group. + """ + return pulumi.get(self, "policy") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the affinity group is associated. + """ + return pulumi.get(self, "project_id") + + +class AwaitableGetAffinityGroupResult(GetAffinityGroupResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetAffinityGroupResult( + affinity_group_id=self.affinity_group_id, + id=self.id, + members=self.members, + name=self.name, + policy=self.policy, + project_id=self.project_id) + + +def get_affinity_group(affinity_group_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetAffinityGroupResult: + """ + Affinity Group schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str affinity_group_id: The affinity group ID. + :param builtins.str project_id: STACKIT Project ID to which the affinity group is associated. + """ + __args__ = dict() + __args__['affinityGroupId'] = affinity_group_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getAffinityGroup:getAffinityGroup', __args__, opts=opts, typ=GetAffinityGroupResult).value + + return AwaitableGetAffinityGroupResult( + affinity_group_id=pulumi.get(__ret__, 'affinity_group_id'), + id=pulumi.get(__ret__, 'id'), + members=pulumi.get(__ret__, 'members'), + name=pulumi.get(__ret__, 'name'), + policy=pulumi.get(__ret__, 'policy'), + project_id=pulumi.get(__ret__, 'project_id')) +def get_affinity_group_output(affinity_group_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetAffinityGroupResult]: + """ + Affinity Group schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str affinity_group_id: The affinity group ID. + :param builtins.str project_id: STACKIT Project ID to which the affinity group is associated. + """ + __args__ = dict() + __args__['affinityGroupId'] = affinity_group_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getAffinityGroup:getAffinityGroup', __args__, opts=opts, typ=GetAffinityGroupResult) + return __ret__.apply(lambda __response__: GetAffinityGroupResult( + affinity_group_id=pulumi.get(__response__, 'affinity_group_id'), + id=pulumi.get(__response__, 'id'), + members=pulumi.get(__response__, 'members'), + name=pulumi.get(__response__, 'name'), + policy=pulumi.get(__response__, 'policy'), + project_id=pulumi.get(__response__, 'project_id'))) diff --git a/sdk/python/pulumi_stackit/get_cdn_custom_domain.py b/sdk/python/pulumi_stackit/get_cdn_custom_domain.py new file mode 100644 index 0000000..3cc45aa --- /dev/null +++ b/sdk/python/pulumi_stackit/get_cdn_custom_domain.py @@ -0,0 +1,163 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetCdnCustomDomainResult', + 'AwaitableGetCdnCustomDomainResult', + 'get_cdn_custom_domain', + 'get_cdn_custom_domain_output', +] + +@pulumi.output_type +class GetCdnCustomDomainResult: + """ + A collection of values returned by getCdnCustomDomain. + """ + def __init__(__self__, distribution_id=None, errors=None, id=None, name=None, project_id=None, status=None): + if distribution_id and not isinstance(distribution_id, str): + raise TypeError("Expected argument 'distribution_id' to be a str") + pulumi.set(__self__, "distribution_id", distribution_id) + if errors and not isinstance(errors, list): + raise TypeError("Expected argument 'errors' to be a list") + pulumi.set(__self__, "errors", errors) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> builtins.str: + """ + CDN distribution ID + """ + return pulumi.get(self, "distribution_id") + + @property + @pulumi.getter + def errors(self) -> Sequence[builtins.str]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def status(self) -> builtins.str: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + + +class AwaitableGetCdnCustomDomainResult(GetCdnCustomDomainResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetCdnCustomDomainResult( + distribution_id=self.distribution_id, + errors=self.errors, + id=self.id, + name=self.name, + project_id=self.project_id, + status=self.status) + + +def get_cdn_custom_domain(distribution_id: Optional[builtins.str] = None, + name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCdnCustomDomainResult: + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str distribution_id: CDN distribution ID + :param builtins.str project_id: STACKIT project ID associated with the distribution + """ + __args__ = dict() + __args__['distributionId'] = distribution_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getCdnCustomDomain:getCdnCustomDomain', __args__, opts=opts, typ=GetCdnCustomDomainResult).value + + return AwaitableGetCdnCustomDomainResult( + distribution_id=pulumi.get(__ret__, 'distribution_id'), + errors=pulumi.get(__ret__, 'errors'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + status=pulumi.get(__ret__, 'status')) +def get_cdn_custom_domain_output(distribution_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetCdnCustomDomainResult]: + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str distribution_id: CDN distribution ID + :param builtins.str project_id: STACKIT project ID associated with the distribution + """ + __args__ = dict() + __args__['distributionId'] = distribution_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getCdnCustomDomain:getCdnCustomDomain', __args__, opts=opts, typ=GetCdnCustomDomainResult) + return __ret__.apply(lambda __response__: GetCdnCustomDomainResult( + distribution_id=pulumi.get(__response__, 'distribution_id'), + errors=pulumi.get(__response__, 'errors'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + status=pulumi.get(__response__, 'status'))) diff --git a/sdk/python/pulumi_stackit/get_cdn_distribution.py b/sdk/python/pulumi_stackit/get_cdn_distribution.py new file mode 100644 index 0000000..0e04a1c --- /dev/null +++ b/sdk/python/pulumi_stackit/get_cdn_distribution.py @@ -0,0 +1,205 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetCdnDistributionResult', + 'AwaitableGetCdnDistributionResult', + 'get_cdn_distribution', + 'get_cdn_distribution_output', +] + +@pulumi.output_type +class GetCdnDistributionResult: + """ + A collection of values returned by getCdnDistribution. + """ + def __init__(__self__, config=None, created_at=None, distribution_id=None, domains=None, errors=None, id=None, project_id=None, status=None, updated_at=None): + if config and not isinstance(config, dict): + raise TypeError("Expected argument 'config' to be a dict") + pulumi.set(__self__, "config", config) + if created_at and not isinstance(created_at, str): + raise TypeError("Expected argument 'created_at' to be a str") + pulumi.set(__self__, "created_at", created_at) + if distribution_id and not isinstance(distribution_id, str): + raise TypeError("Expected argument 'distribution_id' to be a str") + pulumi.set(__self__, "distribution_id", distribution_id) + if domains and not isinstance(domains, list): + raise TypeError("Expected argument 'domains' to be a list") + pulumi.set(__self__, "domains", domains) + if errors and not isinstance(errors, list): + raise TypeError("Expected argument 'errors' to be a list") + pulumi.set(__self__, "errors", errors) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if status and not isinstance(status, str): + raise TypeError("Expected argument 'status' to be a str") + pulumi.set(__self__, "status", status) + if updated_at and not isinstance(updated_at, str): + raise TypeError("Expected argument 'updated_at' to be a str") + pulumi.set(__self__, "updated_at", updated_at) + + @property + @pulumi.getter + def config(self) -> 'outputs.GetCdnDistributionConfigResult': + """ + The distribution configuration + """ + return pulumi.get(self, "config") + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> builtins.str: + """ + Time when the distribution was created + """ + return pulumi.get(self, "created_at") + + @property + @pulumi.getter(name="distributionId") + def distribution_id(self) -> builtins.str: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "distribution_id") + + @property + @pulumi.getter + def domains(self) -> Sequence['outputs.GetCdnDistributionDomainResult']: + """ + List of configured domains for the distribution + """ + return pulumi.get(self, "domains") + + @property + @pulumi.getter + def errors(self) -> Sequence[builtins.str]: + """ + List of distribution errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID associated with the distribution + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def status(self) -> builtins.str: + """ + Status of the distribution + """ + return pulumi.get(self, "status") + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> builtins.str: + """ + Time when the distribution was last updated + """ + return pulumi.get(self, "updated_at") + + +class AwaitableGetCdnDistributionResult(GetCdnDistributionResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetCdnDistributionResult( + config=self.config, + created_at=self.created_at, + distribution_id=self.distribution_id, + domains=self.domains, + errors=self.errors, + id=self.id, + project_id=self.project_id, + status=self.status, + updated_at=self.updated_at) + + +def get_cdn_distribution(distribution_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetCdnDistributionResult: + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str distribution_id: STACKIT project ID associated with the distribution + :param builtins.str project_id: STACKIT project ID associated with the distribution + """ + __args__ = dict() + __args__['distributionId'] = distribution_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getCdnDistribution:getCdnDistribution', __args__, opts=opts, typ=GetCdnDistributionResult).value + + return AwaitableGetCdnDistributionResult( + config=pulumi.get(__ret__, 'config'), + created_at=pulumi.get(__ret__, 'created_at'), + distribution_id=pulumi.get(__ret__, 'distribution_id'), + domains=pulumi.get(__ret__, 'domains'), + errors=pulumi.get(__ret__, 'errors'), + id=pulumi.get(__ret__, 'id'), + project_id=pulumi.get(__ret__, 'project_id'), + status=pulumi.get(__ret__, 'status'), + updated_at=pulumi.get(__ret__, 'updated_at')) +def get_cdn_distribution_output(distribution_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetCdnDistributionResult]: + """ + CDN distribution data source schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str distribution_id: STACKIT project ID associated with the distribution + :param builtins.str project_id: STACKIT project ID associated with the distribution + """ + __args__ = dict() + __args__['distributionId'] = distribution_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getCdnDistribution:getCdnDistribution', __args__, opts=opts, typ=GetCdnDistributionResult) + return __ret__.apply(lambda __response__: GetCdnDistributionResult( + config=pulumi.get(__response__, 'config'), + created_at=pulumi.get(__response__, 'created_at'), + distribution_id=pulumi.get(__response__, 'distribution_id'), + domains=pulumi.get(__response__, 'domains'), + errors=pulumi.get(__response__, 'errors'), + id=pulumi.get(__response__, 'id'), + project_id=pulumi.get(__response__, 'project_id'), + status=pulumi.get(__response__, 'status'), + updated_at=pulumi.get(__response__, 'updated_at'))) diff --git a/sdk/python/pulumi_stackit/get_dns_record_set.py b/sdk/python/pulumi_stackit/get_dns_record_set.py new file mode 100644 index 0000000..de9ce4b --- /dev/null +++ b/sdk/python/pulumi_stackit/get_dns_record_set.py @@ -0,0 +1,262 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetDnsRecordSetResult', + 'AwaitableGetDnsRecordSetResult', + 'get_dns_record_set', + 'get_dns_record_set_output', +] + +@pulumi.output_type +class GetDnsRecordSetResult: + """ + A collection of values returned by getDnsRecordSet. + """ + def __init__(__self__, active=None, comment=None, error=None, fqdn=None, id=None, name=None, project_id=None, record_set_id=None, records=None, state=None, ttl=None, type=None, zone_id=None): + if active and not isinstance(active, bool): + raise TypeError("Expected argument 'active' to be a bool") + pulumi.set(__self__, "active", active) + if comment and not isinstance(comment, str): + raise TypeError("Expected argument 'comment' to be a str") + pulumi.set(__self__, "comment", comment) + if error and not isinstance(error, str): + raise TypeError("Expected argument 'error' to be a str") + pulumi.set(__self__, "error", error) + if fqdn and not isinstance(fqdn, str): + raise TypeError("Expected argument 'fqdn' to be a str") + pulumi.set(__self__, "fqdn", fqdn) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if record_set_id and not isinstance(record_set_id, str): + raise TypeError("Expected argument 'record_set_id' to be a str") + pulumi.set(__self__, "record_set_id", record_set_id) + if records and not isinstance(records, list): + raise TypeError("Expected argument 'records' to be a list") + pulumi.set(__self__, "records", records) + if state and not isinstance(state, str): + raise TypeError("Expected argument 'state' to be a str") + pulumi.set(__self__, "state", state) + if ttl and not isinstance(ttl, int): + raise TypeError("Expected argument 'ttl' to be a int") + pulumi.set(__self__, "ttl", ttl) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if zone_id and not isinstance(zone_id, str): + raise TypeError("Expected argument 'zone_id' to be a str") + pulumi.set(__self__, "zone_id", zone_id) + + @property + @pulumi.getter + def active(self) -> builtins.bool: + """ + Specifies if the record set is active or not. + """ + return pulumi.get(self, "active") + + @property + @pulumi.getter + def comment(self) -> builtins.str: + """ + Comment. + """ + return pulumi.get(self, "comment") + + @property + @pulumi.getter + def error(self) -> builtins.str: + """ + Error shows error in case create/update/delete failed. + """ + return pulumi.get(self, "error") + + @property + @pulumi.getter + def fqdn(self) -> builtins.str: + """ + Fully qualified domain name (FQDN) of the record set. + """ + return pulumi.get(self, "fqdn") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Name of the record which should be a valid domain according to rfc1035 Section 2.3.4. E.g. `example.com` + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the dns record set is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="recordSetId") + def record_set_id(self) -> builtins.str: + """ + The rr set id. + """ + return pulumi.get(self, "record_set_id") + + @property + @pulumi.getter + def records(self) -> Sequence[builtins.str]: + """ + Records. + """ + return pulumi.get(self, "records") + + @property + @pulumi.getter + def state(self) -> builtins.str: + """ + Record set state. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def ttl(self) -> builtins.int: + """ + Time to live. E.g. 3600 + """ + return pulumi.get(self, "ttl") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The record set type. E.g. `A` or `CNAME` + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> builtins.str: + """ + The zone ID to which is dns record set is associated. + """ + return pulumi.get(self, "zone_id") + + +class AwaitableGetDnsRecordSetResult(GetDnsRecordSetResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDnsRecordSetResult( + active=self.active, + comment=self.comment, + error=self.error, + fqdn=self.fqdn, + id=self.id, + name=self.name, + project_id=self.project_id, + record_set_id=self.record_set_id, + records=self.records, + state=self.state, + ttl=self.ttl, + type=self.type, + zone_id=self.zone_id) + + +def get_dns_record_set(project_id: Optional[builtins.str] = None, + record_set_id: Optional[builtins.str] = None, + zone_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDnsRecordSetResult: + """ + DNS Record Set Resource schema. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the dns record set is associated. + :param builtins.str record_set_id: The rr set id. + :param builtins.str zone_id: The zone ID to which is dns record set is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['recordSetId'] = record_set_id + __args__['zoneId'] = zone_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getDnsRecordSet:getDnsRecordSet', __args__, opts=opts, typ=GetDnsRecordSetResult).value + + return AwaitableGetDnsRecordSetResult( + active=pulumi.get(__ret__, 'active'), + comment=pulumi.get(__ret__, 'comment'), + error=pulumi.get(__ret__, 'error'), + fqdn=pulumi.get(__ret__, 'fqdn'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + record_set_id=pulumi.get(__ret__, 'record_set_id'), + records=pulumi.get(__ret__, 'records'), + state=pulumi.get(__ret__, 'state'), + ttl=pulumi.get(__ret__, 'ttl'), + type=pulumi.get(__ret__, 'type'), + zone_id=pulumi.get(__ret__, 'zone_id')) +def get_dns_record_set_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + record_set_id: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDnsRecordSetResult]: + """ + DNS Record Set Resource schema. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the dns record set is associated. + :param builtins.str record_set_id: The rr set id. + :param builtins.str zone_id: The zone ID to which is dns record set is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['recordSetId'] = record_set_id + __args__['zoneId'] = zone_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getDnsRecordSet:getDnsRecordSet', __args__, opts=opts, typ=GetDnsRecordSetResult) + return __ret__.apply(lambda __response__: GetDnsRecordSetResult( + active=pulumi.get(__response__, 'active'), + comment=pulumi.get(__response__, 'comment'), + error=pulumi.get(__response__, 'error'), + fqdn=pulumi.get(__response__, 'fqdn'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + record_set_id=pulumi.get(__response__, 'record_set_id'), + records=pulumi.get(__response__, 'records'), + state=pulumi.get(__response__, 'state'), + ttl=pulumi.get(__response__, 'ttl'), + type=pulumi.get(__response__, 'type'), + zone_id=pulumi.get(__response__, 'zone_id'))) diff --git a/sdk/python/pulumi_stackit/get_dns_zone.py b/sdk/python/pulumi_stackit/get_dns_zone.py new file mode 100644 index 0000000..2b9f64b --- /dev/null +++ b/sdk/python/pulumi_stackit/get_dns_zone.py @@ -0,0 +1,385 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetDnsZoneResult', + 'AwaitableGetDnsZoneResult', + 'get_dns_zone', + 'get_dns_zone_output', +] + +@pulumi.output_type +class GetDnsZoneResult: + """ + A collection of values returned by getDnsZone. + """ + def __init__(__self__, acl=None, active=None, contact_email=None, default_ttl=None, description=None, dns_name=None, expire_time=None, id=None, is_reverse_zone=None, name=None, negative_cache=None, primaries=None, primary_name_server=None, project_id=None, record_count=None, refresh_time=None, retry_time=None, serial_number=None, state=None, type=None, visibility=None, zone_id=None): + if acl and not isinstance(acl, str): + raise TypeError("Expected argument 'acl' to be a str") + pulumi.set(__self__, "acl", acl) + if active and not isinstance(active, bool): + raise TypeError("Expected argument 'active' to be a bool") + pulumi.set(__self__, "active", active) + if contact_email and not isinstance(contact_email, str): + raise TypeError("Expected argument 'contact_email' to be a str") + pulumi.set(__self__, "contact_email", contact_email) + if default_ttl and not isinstance(default_ttl, int): + raise TypeError("Expected argument 'default_ttl' to be a int") + pulumi.set(__self__, "default_ttl", default_ttl) + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if dns_name and not isinstance(dns_name, str): + raise TypeError("Expected argument 'dns_name' to be a str") + pulumi.set(__self__, "dns_name", dns_name) + if expire_time and not isinstance(expire_time, int): + raise TypeError("Expected argument 'expire_time' to be a int") + pulumi.set(__self__, "expire_time", expire_time) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_reverse_zone and not isinstance(is_reverse_zone, bool): + raise TypeError("Expected argument 'is_reverse_zone' to be a bool") + pulumi.set(__self__, "is_reverse_zone", is_reverse_zone) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if negative_cache and not isinstance(negative_cache, int): + raise TypeError("Expected argument 'negative_cache' to be a int") + pulumi.set(__self__, "negative_cache", negative_cache) + if primaries and not isinstance(primaries, list): + raise TypeError("Expected argument 'primaries' to be a list") + pulumi.set(__self__, "primaries", primaries) + if primary_name_server and not isinstance(primary_name_server, str): + raise TypeError("Expected argument 'primary_name_server' to be a str") + pulumi.set(__self__, "primary_name_server", primary_name_server) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if record_count and not isinstance(record_count, int): + raise TypeError("Expected argument 'record_count' to be a int") + pulumi.set(__self__, "record_count", record_count) + if refresh_time and not isinstance(refresh_time, int): + raise TypeError("Expected argument 'refresh_time' to be a int") + pulumi.set(__self__, "refresh_time", refresh_time) + if retry_time and not isinstance(retry_time, int): + raise TypeError("Expected argument 'retry_time' to be a int") + pulumi.set(__self__, "retry_time", retry_time) + if serial_number and not isinstance(serial_number, int): + raise TypeError("Expected argument 'serial_number' to be a int") + pulumi.set(__self__, "serial_number", serial_number) + if state and not isinstance(state, str): + raise TypeError("Expected argument 'state' to be a str") + pulumi.set(__self__, "state", state) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + if visibility and not isinstance(visibility, str): + raise TypeError("Expected argument 'visibility' to be a str") + pulumi.set(__self__, "visibility", visibility) + if zone_id and not isinstance(zone_id, str): + raise TypeError("Expected argument 'zone_id' to be a str") + pulumi.set(__self__, "zone_id", zone_id) + + @property + @pulumi.getter + def acl(self) -> builtins.str: + """ + The access control list. + """ + return pulumi.get(self, "acl") + + @property + @pulumi.getter + def active(self) -> builtins.bool: + return pulumi.get(self, "active") + + @property + @pulumi.getter(name="contactEmail") + def contact_email(self) -> builtins.str: + """ + A contact e-mail for the zone. + """ + return pulumi.get(self, "contact_email") + + @property + @pulumi.getter(name="defaultTtl") + def default_ttl(self) -> builtins.int: + """ + Default time to live. + """ + return pulumi.get(self, "default_ttl") + + @property + @pulumi.getter + def description(self) -> builtins.str: + """ + Description of the zone. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="dnsName") + def dns_name(self) -> Optional[builtins.str]: + """ + The zone name. E.g. `example.com` + """ + return pulumi.get(self, "dns_name") + + @property + @pulumi.getter(name="expireTime") + def expire_time(self) -> builtins.int: + """ + Expire time. + """ + return pulumi.get(self, "expire_time") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="isReverseZone") + def is_reverse_zone(self) -> builtins.bool: + """ + Specifies, if the zone is a reverse zone or not. + """ + return pulumi.get(self, "is_reverse_zone") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The user given name of the zone. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="negativeCache") + def negative_cache(self) -> builtins.int: + """ + Negative caching. + """ + return pulumi.get(self, "negative_cache") + + @property + @pulumi.getter + def primaries(self) -> Sequence[builtins.str]: + """ + Primary name server for secondary zone. + """ + return pulumi.get(self, "primaries") + + @property + @pulumi.getter(name="primaryNameServer") + def primary_name_server(self) -> builtins.str: + """ + Primary name server. FQDN. + """ + return pulumi.get(self, "primary_name_server") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the dns zone is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="recordCount") + def record_count(self) -> builtins.int: + """ + Record count how many records are in the zone. + """ + return pulumi.get(self, "record_count") + + @property + @pulumi.getter(name="refreshTime") + def refresh_time(self) -> builtins.int: + """ + Refresh time. + """ + return pulumi.get(self, "refresh_time") + + @property + @pulumi.getter(name="retryTime") + def retry_time(self) -> builtins.int: + """ + Retry time. + """ + return pulumi.get(self, "retry_time") + + @property + @pulumi.getter(name="serialNumber") + def serial_number(self) -> builtins.int: + """ + Serial number. + """ + return pulumi.get(self, "serial_number") + + @property + @pulumi.getter + def state(self) -> builtins.str: + """ + Zone state. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + Zone type. + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter + def visibility(self) -> builtins.str: + """ + Visibility of the zone. + """ + return pulumi.get(self, "visibility") + + @property + @pulumi.getter(name="zoneId") + def zone_id(self) -> Optional[builtins.str]: + """ + The zone ID. + """ + return pulumi.get(self, "zone_id") + + +class AwaitableGetDnsZoneResult(GetDnsZoneResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetDnsZoneResult( + acl=self.acl, + active=self.active, + contact_email=self.contact_email, + default_ttl=self.default_ttl, + description=self.description, + dns_name=self.dns_name, + expire_time=self.expire_time, + id=self.id, + is_reverse_zone=self.is_reverse_zone, + name=self.name, + negative_cache=self.negative_cache, + primaries=self.primaries, + primary_name_server=self.primary_name_server, + project_id=self.project_id, + record_count=self.record_count, + refresh_time=self.refresh_time, + retry_time=self.retry_time, + serial_number=self.serial_number, + state=self.state, + type=self.type, + visibility=self.visibility, + zone_id=self.zone_id) + + +def get_dns_zone(dns_name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + zone_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDnsZoneResult: + """ + DNS Zone resource schema. + + ## Example Usage + + + :param builtins.str dns_name: The zone name. E.g. `example.com` + :param builtins.str project_id: STACKIT project ID to which the dns zone is associated. + :param builtins.str zone_id: The zone ID. + """ + __args__ = dict() + __args__['dnsName'] = dns_name + __args__['projectId'] = project_id + __args__['zoneId'] = zone_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getDnsZone:getDnsZone', __args__, opts=opts, typ=GetDnsZoneResult).value + + return AwaitableGetDnsZoneResult( + acl=pulumi.get(__ret__, 'acl'), + active=pulumi.get(__ret__, 'active'), + contact_email=pulumi.get(__ret__, 'contact_email'), + default_ttl=pulumi.get(__ret__, 'default_ttl'), + description=pulumi.get(__ret__, 'description'), + dns_name=pulumi.get(__ret__, 'dns_name'), + expire_time=pulumi.get(__ret__, 'expire_time'), + id=pulumi.get(__ret__, 'id'), + is_reverse_zone=pulumi.get(__ret__, 'is_reverse_zone'), + name=pulumi.get(__ret__, 'name'), + negative_cache=pulumi.get(__ret__, 'negative_cache'), + primaries=pulumi.get(__ret__, 'primaries'), + primary_name_server=pulumi.get(__ret__, 'primary_name_server'), + project_id=pulumi.get(__ret__, 'project_id'), + record_count=pulumi.get(__ret__, 'record_count'), + refresh_time=pulumi.get(__ret__, 'refresh_time'), + retry_time=pulumi.get(__ret__, 'retry_time'), + serial_number=pulumi.get(__ret__, 'serial_number'), + state=pulumi.get(__ret__, 'state'), + type=pulumi.get(__ret__, 'type'), + visibility=pulumi.get(__ret__, 'visibility'), + zone_id=pulumi.get(__ret__, 'zone_id')) +def get_dns_zone_output(dns_name: Optional[pulumi.Input[Optional[builtins.str]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + zone_id: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetDnsZoneResult]: + """ + DNS Zone resource schema. + + ## Example Usage + + + :param builtins.str dns_name: The zone name. E.g. `example.com` + :param builtins.str project_id: STACKIT project ID to which the dns zone is associated. + :param builtins.str zone_id: The zone ID. + """ + __args__ = dict() + __args__['dnsName'] = dns_name + __args__['projectId'] = project_id + __args__['zoneId'] = zone_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getDnsZone:getDnsZone', __args__, opts=opts, typ=GetDnsZoneResult) + return __ret__.apply(lambda __response__: GetDnsZoneResult( + acl=pulumi.get(__response__, 'acl'), + active=pulumi.get(__response__, 'active'), + contact_email=pulumi.get(__response__, 'contact_email'), + default_ttl=pulumi.get(__response__, 'default_ttl'), + description=pulumi.get(__response__, 'description'), + dns_name=pulumi.get(__response__, 'dns_name'), + expire_time=pulumi.get(__response__, 'expire_time'), + id=pulumi.get(__response__, 'id'), + is_reverse_zone=pulumi.get(__response__, 'is_reverse_zone'), + name=pulumi.get(__response__, 'name'), + negative_cache=pulumi.get(__response__, 'negative_cache'), + primaries=pulumi.get(__response__, 'primaries'), + primary_name_server=pulumi.get(__response__, 'primary_name_server'), + project_id=pulumi.get(__response__, 'project_id'), + record_count=pulumi.get(__response__, 'record_count'), + refresh_time=pulumi.get(__response__, 'refresh_time'), + retry_time=pulumi.get(__response__, 'retry_time'), + serial_number=pulumi.get(__response__, 'serial_number'), + state=pulumi.get(__response__, 'state'), + type=pulumi.get(__response__, 'type'), + visibility=pulumi.get(__response__, 'visibility'), + zone_id=pulumi.get(__response__, 'zone_id'))) diff --git a/sdk/python/pulumi_stackit/get_git.py b/sdk/python/pulumi_stackit/get_git.py new file mode 100644 index 0000000..097d9f3 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_git.py @@ -0,0 +1,162 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetGitResult', + 'AwaitableGetGitResult', + 'get_git', + 'get_git_output', +] + +@pulumi.output_type +class GetGitResult: + """ + A collection of values returned by getGit. + """ + def __init__(__self__, id=None, instance_id=None, name=None, project_id=None, url=None, version=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if url and not isinstance(url, str): + raise TypeError("Expected argument 'url' to be a str") + pulumi.set(__self__, "url", url) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID linked to the git instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Unique name linked to the git instance. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the git instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def url(self) -> builtins.str: + """ + Url linked to the git instance. + """ + return pulumi.get(self, "url") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + Version linked to the git instance. + """ + return pulumi.get(self, "version") + + +class AwaitableGetGitResult(GetGitResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetGitResult( + id=self.id, + instance_id=self.instance_id, + name=self.name, + project_id=self.project_id, + url=self.url, + version=self.version) + + +def get_git(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGitResult: + """ + Git Instance datasource schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str instance_id: ID linked to the git instance. + :param builtins.str project_id: STACKIT project ID to which the git instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getGit:getGit', __args__, opts=opts, typ=GetGitResult).value + + return AwaitableGetGitResult( + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + url=pulumi.get(__ret__, 'url'), + version=pulumi.get(__ret__, 'version')) +def get_git_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetGitResult]: + """ + Git Instance datasource schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str instance_id: ID linked to the git instance. + :param builtins.str project_id: STACKIT project ID to which the git instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getGit:getGit', __args__, opts=opts, typ=GetGitResult) + return __ret__.apply(lambda __response__: GetGitResult( + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + url=pulumi.get(__response__, 'url'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_image.py b/sdk/python/pulumi_stackit/get_image.py new file mode 100644 index 0000000..d2c568d --- /dev/null +++ b/sdk/python/pulumi_stackit/get_image.py @@ -0,0 +1,243 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetImageResult', + 'AwaitableGetImageResult', + 'get_image', + 'get_image_output', +] + +@pulumi.output_type +class GetImageResult: + """ + A collection of values returned by getImage. + """ + def __init__(__self__, checksum=None, config=None, disk_format=None, id=None, image_id=None, labels=None, min_disk_size=None, min_ram=None, name=None, project_id=None, protected=None, scope=None): + if checksum and not isinstance(checksum, dict): + raise TypeError("Expected argument 'checksum' to be a dict") + pulumi.set(__self__, "checksum", checksum) + if config and not isinstance(config, dict): + raise TypeError("Expected argument 'config' to be a dict") + pulumi.set(__self__, "config", config) + if disk_format and not isinstance(disk_format, str): + raise TypeError("Expected argument 'disk_format' to be a str") + pulumi.set(__self__, "disk_format", disk_format) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_id and not isinstance(image_id, str): + raise TypeError("Expected argument 'image_id' to be a str") + pulumi.set(__self__, "image_id", image_id) + if labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if min_disk_size and not isinstance(min_disk_size, int): + raise TypeError("Expected argument 'min_disk_size' to be a int") + pulumi.set(__self__, "min_disk_size", min_disk_size) + if min_ram and not isinstance(min_ram, int): + raise TypeError("Expected argument 'min_ram' to be a int") + pulumi.set(__self__, "min_ram", min_ram) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if protected and not isinstance(protected, bool): + raise TypeError("Expected argument 'protected' to be a bool") + pulumi.set(__self__, "protected", protected) + if scope and not isinstance(scope, str): + raise TypeError("Expected argument 'scope' to be a str") + pulumi.set(__self__, "scope", scope) + + @property + @pulumi.getter + def checksum(self) -> 'outputs.GetImageChecksumResult': + """ + Representation of an image checksum. + """ + return pulumi.get(self, "checksum") + + @property + @pulumi.getter + def config(self) -> 'outputs.GetImageConfigResult': + """ + Properties to set hardware and scheduling settings for an image. + """ + return pulumi.get(self, "config") + + @property + @pulumi.getter(name="diskFormat") + def disk_format(self) -> builtins.str: + """ + The disk format of the image. + """ + return pulumi.get(self, "disk_format") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> builtins.str: + """ + The image ID. + """ + return pulumi.get(self, "image_id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="minDiskSize") + def min_disk_size(self) -> builtins.int: + """ + The minimum disk size of the image in GB. + """ + return pulumi.get(self, "min_disk_size") + + @property + @pulumi.getter(name="minRam") + def min_ram(self) -> builtins.int: + """ + The minimum RAM of the image in MB. + """ + return pulumi.get(self, "min_ram") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the image. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the image is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def protected(self) -> builtins.bool: + """ + Whether the image is protected. + """ + return pulumi.get(self, "protected") + + @property + @pulumi.getter + def scope(self) -> builtins.str: + """ + The scope of the image. + """ + return pulumi.get(self, "scope") + + +class AwaitableGetImageResult(GetImageResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetImageResult( + checksum=self.checksum, + config=self.config, + disk_format=self.disk_format, + id=self.id, + image_id=self.image_id, + labels=self.labels, + min_disk_size=self.min_disk_size, + min_ram=self.min_ram, + name=self.name, + project_id=self.project_id, + protected=self.protected, + scope=self.scope) + + +def get_image(image_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetImageResult: + """ + Image datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str image_id: The image ID. + :param builtins.str project_id: STACKIT project ID to which the image is associated. + """ + __args__ = dict() + __args__['imageId'] = image_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getImage:getImage', __args__, opts=opts, typ=GetImageResult).value + + return AwaitableGetImageResult( + checksum=pulumi.get(__ret__, 'checksum'), + config=pulumi.get(__ret__, 'config'), + disk_format=pulumi.get(__ret__, 'disk_format'), + id=pulumi.get(__ret__, 'id'), + image_id=pulumi.get(__ret__, 'image_id'), + labels=pulumi.get(__ret__, 'labels'), + min_disk_size=pulumi.get(__ret__, 'min_disk_size'), + min_ram=pulumi.get(__ret__, 'min_ram'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + protected=pulumi.get(__ret__, 'protected'), + scope=pulumi.get(__ret__, 'scope')) +def get_image_output(image_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetImageResult]: + """ + Image datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str image_id: The image ID. + :param builtins.str project_id: STACKIT project ID to which the image is associated. + """ + __args__ = dict() + __args__['imageId'] = image_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getImage:getImage', __args__, opts=opts, typ=GetImageResult) + return __ret__.apply(lambda __response__: GetImageResult( + checksum=pulumi.get(__response__, 'checksum'), + config=pulumi.get(__response__, 'config'), + disk_format=pulumi.get(__response__, 'disk_format'), + id=pulumi.get(__response__, 'id'), + image_id=pulumi.get(__response__, 'image_id'), + labels=pulumi.get(__response__, 'labels'), + min_disk_size=pulumi.get(__response__, 'min_disk_size'), + min_ram=pulumi.get(__response__, 'min_ram'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + protected=pulumi.get(__response__, 'protected'), + scope=pulumi.get(__response__, 'scope'))) diff --git a/sdk/python/pulumi_stackit/get_key_pair.py b/sdk/python/pulumi_stackit/get_key_pair.py new file mode 100644 index 0000000..7a745e0 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_key_pair.py @@ -0,0 +1,138 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetKeyPairResult', + 'AwaitableGetKeyPairResult', + 'get_key_pair', + 'get_key_pair_output', +] + +@pulumi.output_type +class GetKeyPairResult: + """ + A collection of values returned by getKeyPair. + """ + def __init__(__self__, fingerprint=None, id=None, labels=None, name=None, public_key=None): + if fingerprint and not isinstance(fingerprint, str): + raise TypeError("Expected argument 'fingerprint' to be a str") + pulumi.set(__self__, "fingerprint", fingerprint) + 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, dict): + raise TypeError("Expected argument 'labels' to be a dict") + 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 public_key and not isinstance(public_key, str): + raise TypeError("Expected argument 'public_key' to be a str") + pulumi.set(__self__, "public_key", public_key) + + @property + @pulumi.getter + def fingerprint(self) -> builtins.str: + """ + The fingerprint of the public SSH key. + """ + return pulumi.get(self, "fingerprint") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the SSH key pair. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> builtins.str: + """ + A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + return pulumi.get(self, "public_key") + + +class AwaitableGetKeyPairResult(GetKeyPairResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetKeyPairResult( + fingerprint=self.fingerprint, + id=self.id, + labels=self.labels, + name=self.name, + public_key=self.public_key) + + +def get_key_pair(name: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetKeyPairResult: + """ + Key pair resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The name of the SSH key pair. + """ + __args__ = dict() + __args__['name'] = name + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getKeyPair:getKeyPair', __args__, opts=opts, typ=GetKeyPairResult).value + + return AwaitableGetKeyPairResult( + fingerprint=pulumi.get(__ret__, 'fingerprint'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + public_key=pulumi.get(__ret__, 'public_key')) +def get_key_pair_output(name: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetKeyPairResult]: + """ + Key pair resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The name of the SSH key pair. + """ + __args__ = dict() + __args__['name'] = name + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getKeyPair:getKeyPair', __args__, opts=opts, typ=GetKeyPairResult) + return __ret__.apply(lambda __response__: GetKeyPairResult( + fingerprint=pulumi.get(__response__, 'fingerprint'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + name=pulumi.get(__response__, 'name'), + public_key=pulumi.get(__response__, 'public_key'))) diff --git a/sdk/python/pulumi_stackit/get_loadbalancer.py b/sdk/python/pulumi_stackit/get_loadbalancer.py new file mode 100644 index 0000000..1312e89 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_loadbalancer.py @@ -0,0 +1,221 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetLoadbalancerResult', + 'AwaitableGetLoadbalancerResult', + 'get_loadbalancer', + 'get_loadbalancer_output', +] + +@pulumi.output_type +class GetLoadbalancerResult: + """ + A collection of values returned by getLoadbalancer. + """ + def __init__(__self__, external_address=None, id=None, listeners=None, name=None, networks=None, options=None, private_address=None, project_id=None, region=None, target_pools=None): + if external_address and not isinstance(external_address, str): + raise TypeError("Expected argument 'external_address' to be a str") + pulumi.set(__self__, "external_address", external_address) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if listeners and not isinstance(listeners, list): + raise TypeError("Expected argument 'listeners' to be a list") + pulumi.set(__self__, "listeners", listeners) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if networks and not isinstance(networks, list): + raise TypeError("Expected argument 'networks' to be a list") + pulumi.set(__self__, "networks", networks) + if options and not isinstance(options, dict): + raise TypeError("Expected argument 'options' to be a dict") + pulumi.set(__self__, "options", options) + if private_address and not isinstance(private_address, str): + raise TypeError("Expected argument 'private_address' to be a str") + pulumi.set(__self__, "private_address", private_address) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if target_pools and not isinstance(target_pools, list): + raise TypeError("Expected argument 'target_pools' to be a list") + pulumi.set(__self__, "target_pools", target_pools) + + @property + @pulumi.getter(name="externalAddress") + def external_address(self) -> builtins.str: + """ + External Load Balancer IP address where this Load Balancer is exposed. + """ + return pulumi.get(self, "external_address") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def listeners(self) -> Sequence['outputs.GetLoadbalancerListenerResult']: + """ + List of all listeners which will accept traffic. Limited to 20. + """ + return pulumi.get(self, "listeners") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Load balancer name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def networks(self) -> Sequence['outputs.GetLoadbalancerNetworkResult']: + """ + List of networks that listeners and targets reside in. + """ + return pulumi.get(self, "networks") + + @property + @pulumi.getter + def options(self) -> 'outputs.GetLoadbalancerOptionsResult': + """ + Defines any optional functionality you want to have enabled on your load balancer. + """ + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="privateAddress") + def private_address(self) -> builtins.str: + """ + Transient private Load Balancer IP address. It can change any time. + """ + return pulumi.get(self, "private_address") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the Load Balancer is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="targetPools") + def target_pools(self) -> Sequence['outputs.GetLoadbalancerTargetPoolResult']: + """ + List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + return pulumi.get(self, "target_pools") + + +class AwaitableGetLoadbalancerResult(GetLoadbalancerResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetLoadbalancerResult( + external_address=self.external_address, + id=self.id, + listeners=self.listeners, + name=self.name, + networks=self.networks, + options=self.options, + private_address=self.private_address, + project_id=self.project_id, + region=self.region, + target_pools=self.target_pools) + + +def get_loadbalancer(name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLoadbalancerResult: + """ + Load Balancer data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: Load balancer name. + :param builtins.str project_id: STACKIT project ID to which the Load Balancer is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getLoadbalancer:getLoadbalancer', __args__, opts=opts, typ=GetLoadbalancerResult).value + + return AwaitableGetLoadbalancerResult( + external_address=pulumi.get(__ret__, 'external_address'), + id=pulumi.get(__ret__, 'id'), + listeners=pulumi.get(__ret__, 'listeners'), + name=pulumi.get(__ret__, 'name'), + networks=pulumi.get(__ret__, 'networks'), + options=pulumi.get(__ret__, 'options'), + private_address=pulumi.get(__ret__, 'private_address'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + target_pools=pulumi.get(__ret__, 'target_pools')) +def get_loadbalancer_output(name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLoadbalancerResult]: + """ + Load Balancer data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: Load balancer name. + :param builtins.str project_id: STACKIT project ID to which the Load Balancer is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getLoadbalancer:getLoadbalancer', __args__, opts=opts, typ=GetLoadbalancerResult) + return __ret__.apply(lambda __response__: GetLoadbalancerResult( + external_address=pulumi.get(__response__, 'external_address'), + id=pulumi.get(__response__, 'id'), + listeners=pulumi.get(__response__, 'listeners'), + name=pulumi.get(__response__, 'name'), + networks=pulumi.get(__response__, 'networks'), + options=pulumi.get(__response__, 'options'), + private_address=pulumi.get(__response__, 'private_address'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + target_pools=pulumi.get(__response__, 'target_pools'))) diff --git a/sdk/python/pulumi_stackit/get_logme_credential.py b/sdk/python/pulumi_stackit/get_logme_credential.py new file mode 100644 index 0000000..5bcb63e --- /dev/null +++ b/sdk/python/pulumi_stackit/get_logme_credential.py @@ -0,0 +1,191 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetLogmeCredentialResult', + 'AwaitableGetLogmeCredentialResult', + 'get_logme_credential', + 'get_logme_credential_output', +] + +@pulumi.output_type +class GetLogmeCredentialResult: + """ + A collection of values returned by getLogmeCredential. + """ + def __init__(__self__, credential_id=None, host=None, id=None, instance_id=None, password=None, port=None, project_id=None, uri=None, username=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if password and not isinstance(password, str): + raise TypeError("Expected argument 'password' to be a str") + pulumi.set(__self__, "password", password) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if uri and not isinstance(uri, str): + raise TypeError("Expected argument 'uri' to be a str") + pulumi.set(__self__, "uri", uri) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> builtins.str: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> builtins.str: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetLogmeCredentialResult(GetLogmeCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetLogmeCredentialResult( + credential_id=self.credential_id, + host=self.host, + id=self.id, + instance_id=self.instance_id, + password=self.password, + port=self.port, + project_id=self.project_id, + uri=self.uri, + username=self.username) + + +def get_logme_credential(credential_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLogmeCredentialResult: + """ + LogMe credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the LogMe instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getLogmeCredential:getLogmeCredential', __args__, opts=opts, typ=GetLogmeCredentialResult).value + + return AwaitableGetLogmeCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + host=pulumi.get(__ret__, 'host'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + password=pulumi.get(__ret__, 'password'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + uri=pulumi.get(__ret__, 'uri'), + username=pulumi.get(__ret__, 'username')) +def get_logme_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLogmeCredentialResult]: + """ + LogMe credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the LogMe instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getLogmeCredential:getLogmeCredential', __args__, opts=opts, typ=GetLogmeCredentialResult) + return __ret__.apply(lambda __response__: GetLogmeCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + host=pulumi.get(__response__, 'host'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + password=pulumi.get(__response__, 'password'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + uri=pulumi.get(__response__, 'uri'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_logme_instance.py b/sdk/python/pulumi_stackit/get_logme_instance.py new file mode 100644 index 0000000..d2a7642 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_logme_instance.py @@ -0,0 +1,239 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetLogmeInstanceResult', + 'AwaitableGetLogmeInstanceResult', + 'get_logme_instance', + 'get_logme_instance_output', +] + +@pulumi.output_type +class GetLogmeInstanceResult: + """ + A collection of values returned by getLogmeInstance. + """ + def __init__(__self__, cf_guid=None, cf_organization_guid=None, cf_space_guid=None, dashboard_url=None, id=None, image_url=None, instance_id=None, name=None, parameters=None, plan_id=None, plan_name=None, project_id=None, version=None): + if cf_guid and not isinstance(cf_guid, str): + raise TypeError("Expected argument 'cf_guid' to be a str") + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid and not isinstance(cf_organization_guid, str): + raise TypeError("Expected argument 'cf_organization_guid' to be a str") + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid and not isinstance(cf_space_guid, str): + raise TypeError("Expected argument 'cf_space_guid' to be a str") + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_url and not isinstance(image_url, str): + raise TypeError("Expected argument 'image_url' to be a str") + pulumi.set(__self__, "image_url", image_url) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> builtins.str: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> builtins.str: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> builtins.str: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> builtins.str: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> 'outputs.GetLogmeInstanceParametersResult': + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + The service version. + """ + return pulumi.get(self, "version") + + +class AwaitableGetLogmeInstanceResult(GetLogmeInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetLogmeInstanceResult( + cf_guid=self.cf_guid, + cf_organization_guid=self.cf_organization_guid, + cf_space_guid=self.cf_space_guid, + dashboard_url=self.dashboard_url, + id=self.id, + image_url=self.image_url, + instance_id=self.instance_id, + name=self.name, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + version=self.version) + + +def get_logme_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetLogmeInstanceResult: + """ + LogMe instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the LogMe instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getLogmeInstance:getLogmeInstance', __args__, opts=opts, typ=GetLogmeInstanceResult).value + + return AwaitableGetLogmeInstanceResult( + cf_guid=pulumi.get(__ret__, 'cf_guid'), + cf_organization_guid=pulumi.get(__ret__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__ret__, 'cf_space_guid'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + id=pulumi.get(__ret__, 'id'), + image_url=pulumi.get(__ret__, 'image_url'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + version=pulumi.get(__ret__, 'version')) +def get_logme_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetLogmeInstanceResult]: + """ + LogMe instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the LogMe instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getLogmeInstance:getLogmeInstance', __args__, opts=opts, typ=GetLogmeInstanceResult) + return __ret__.apply(lambda __response__: GetLogmeInstanceResult( + cf_guid=pulumi.get(__response__, 'cf_guid'), + cf_organization_guid=pulumi.get(__response__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__response__, 'cf_space_guid'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + id=pulumi.get(__response__, 'id'), + image_url=pulumi.get(__response__, 'image_url'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_mariadb_credential.py b/sdk/python/pulumi_stackit/get_mariadb_credential.py new file mode 100644 index 0000000..3525a60 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_mariadb_credential.py @@ -0,0 +1,213 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetMariadbCredentialResult', + 'AwaitableGetMariadbCredentialResult', + 'get_mariadb_credential', + 'get_mariadb_credential_output', +] + +@pulumi.output_type +class GetMariadbCredentialResult: + """ + A collection of values returned by getMariadbCredential. + """ + def __init__(__self__, credential_id=None, host=None, hosts=None, id=None, instance_id=None, name=None, password=None, port=None, project_id=None, uri=None, username=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if hosts and not isinstance(hosts, list): + raise TypeError("Expected argument 'hosts' to be a list") + pulumi.set(__self__, "hosts", hosts) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if password and not isinstance(password, str): + raise TypeError("Expected argument 'password' to be a str") + pulumi.set(__self__, "password", password) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if uri and not isinstance(uri, str): + raise TypeError("Expected argument 'uri' to be a str") + pulumi.set(__self__, "uri", uri) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> Sequence[builtins.str]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def password(self) -> builtins.str: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> builtins.str: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetMariadbCredentialResult(GetMariadbCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetMariadbCredentialResult( + credential_id=self.credential_id, + host=self.host, + hosts=self.hosts, + id=self.id, + instance_id=self.instance_id, + name=self.name, + password=self.password, + port=self.port, + project_id=self.project_id, + uri=self.uri, + username=self.username) + + +def get_mariadb_credential(credential_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMariadbCredentialResult: + """ + MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the MariaDB instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getMariadbCredential:getMariadbCredential', __args__, opts=opts, typ=GetMariadbCredentialResult).value + + return AwaitableGetMariadbCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + host=pulumi.get(__ret__, 'host'), + hosts=pulumi.get(__ret__, 'hosts'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + password=pulumi.get(__ret__, 'password'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + uri=pulumi.get(__ret__, 'uri'), + username=pulumi.get(__ret__, 'username')) +def get_mariadb_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMariadbCredentialResult]: + """ + MariaDB credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the MariaDB instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getMariadbCredential:getMariadbCredential', __args__, opts=opts, typ=GetMariadbCredentialResult) + return __ret__.apply(lambda __response__: GetMariadbCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + host=pulumi.get(__response__, 'host'), + hosts=pulumi.get(__response__, 'hosts'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + password=pulumi.get(__response__, 'password'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + uri=pulumi.get(__response__, 'uri'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_mariadb_instance.py b/sdk/python/pulumi_stackit/get_mariadb_instance.py new file mode 100644 index 0000000..7f069fe --- /dev/null +++ b/sdk/python/pulumi_stackit/get_mariadb_instance.py @@ -0,0 +1,239 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetMariadbInstanceResult', + 'AwaitableGetMariadbInstanceResult', + 'get_mariadb_instance', + 'get_mariadb_instance_output', +] + +@pulumi.output_type +class GetMariadbInstanceResult: + """ + A collection of values returned by getMariadbInstance. + """ + def __init__(__self__, cf_guid=None, cf_organization_guid=None, cf_space_guid=None, dashboard_url=None, id=None, image_url=None, instance_id=None, name=None, parameters=None, plan_id=None, plan_name=None, project_id=None, version=None): + if cf_guid and not isinstance(cf_guid, str): + raise TypeError("Expected argument 'cf_guid' to be a str") + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid and not isinstance(cf_organization_guid, str): + raise TypeError("Expected argument 'cf_organization_guid' to be a str") + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid and not isinstance(cf_space_guid, str): + raise TypeError("Expected argument 'cf_space_guid' to be a str") + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_url and not isinstance(image_url, str): + raise TypeError("Expected argument 'image_url' to be a str") + pulumi.set(__self__, "image_url", image_url) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> builtins.str: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> builtins.str: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> builtins.str: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> builtins.str: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> 'outputs.GetMariadbInstanceParametersResult': + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + The service version. + """ + return pulumi.get(self, "version") + + +class AwaitableGetMariadbInstanceResult(GetMariadbInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetMariadbInstanceResult( + cf_guid=self.cf_guid, + cf_organization_guid=self.cf_organization_guid, + cf_space_guid=self.cf_space_guid, + dashboard_url=self.dashboard_url, + id=self.id, + image_url=self.image_url, + instance_id=self.instance_id, + name=self.name, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + version=self.version) + + +def get_mariadb_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMariadbInstanceResult: + """ + MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MariaDB instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getMariadbInstance:getMariadbInstance', __args__, opts=opts, typ=GetMariadbInstanceResult).value + + return AwaitableGetMariadbInstanceResult( + cf_guid=pulumi.get(__ret__, 'cf_guid'), + cf_organization_guid=pulumi.get(__ret__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__ret__, 'cf_space_guid'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + id=pulumi.get(__ret__, 'id'), + image_url=pulumi.get(__ret__, 'image_url'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + version=pulumi.get(__ret__, 'version')) +def get_mariadb_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMariadbInstanceResult]: + """ + MariaDB instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MariaDB instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getMariadbInstance:getMariadbInstance', __args__, opts=opts, typ=GetMariadbInstanceResult) + return __ret__.apply(lambda __response__: GetMariadbInstanceResult( + cf_guid=pulumi.get(__response__, 'cf_guid'), + cf_organization_guid=pulumi.get(__response__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__response__, 'cf_space_guid'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + id=pulumi.get(__response__, 'id'), + image_url=pulumi.get(__response__, 'image_url'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_mongodbflex_instance.py b/sdk/python/pulumi_stackit/get_mongodbflex_instance.py new file mode 100644 index 0000000..49e62ee --- /dev/null +++ b/sdk/python/pulumi_stackit/get_mongodbflex_instance.py @@ -0,0 +1,217 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetMongodbflexInstanceResult', + 'AwaitableGetMongodbflexInstanceResult', + 'get_mongodbflex_instance', + 'get_mongodbflex_instance_output', +] + +@pulumi.output_type +class GetMongodbflexInstanceResult: + """ + A collection of values returned by getMongodbflexInstance. + """ + def __init__(__self__, acls=None, backup_schedule=None, flavor=None, id=None, instance_id=None, name=None, options=None, project_id=None, replicas=None, storage=None, version=None): + if acls and not isinstance(acls, list): + raise TypeError("Expected argument 'acls' to be a list") + pulumi.set(__self__, "acls", acls) + if backup_schedule and not isinstance(backup_schedule, str): + raise TypeError("Expected argument 'backup_schedule' to be a str") + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor and not isinstance(flavor, dict): + raise TypeError("Expected argument 'flavor' to be a dict") + pulumi.set(__self__, "flavor", flavor) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if options and not isinstance(options, dict): + raise TypeError("Expected argument 'options' to be a dict") + pulumi.set(__self__, "options", options) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if replicas and not isinstance(replicas, int): + raise TypeError("Expected argument 'replicas' to be a int") + pulumi.set(__self__, "replicas", replicas) + if storage and not isinstance(storage, dict): + raise TypeError("Expected argument 'storage' to be a dict") + pulumi.set(__self__, "storage", storage) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + The Access Control List (ACL) for the MongoDB Flex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> builtins.str: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + """ + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> 'outputs.GetMongodbflexInstanceFlavorResult': + return pulumi.get(self, "flavor") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def options(self) -> 'outputs.GetMongodbflexInstanceOptionsResult': + """ + Custom parameters for the MongoDB Flex instance. + """ + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def replicas(self) -> builtins.int: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> 'outputs.GetMongodbflexInstanceStorageResult': + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> builtins.str: + return pulumi.get(self, "version") + + +class AwaitableGetMongodbflexInstanceResult(GetMongodbflexInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetMongodbflexInstanceResult( + acls=self.acls, + backup_schedule=self.backup_schedule, + flavor=self.flavor, + id=self.id, + instance_id=self.instance_id, + name=self.name, + options=self.options, + project_id=self.project_id, + replicas=self.replicas, + storage=self.storage, + version=self.version) + + +def get_mongodbflex_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMongodbflexInstanceResult: + """ + MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MongoDB Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getMongodbflexInstance:getMongodbflexInstance', __args__, opts=opts, typ=GetMongodbflexInstanceResult).value + + return AwaitableGetMongodbflexInstanceResult( + acls=pulumi.get(__ret__, 'acls'), + backup_schedule=pulumi.get(__ret__, 'backup_schedule'), + flavor=pulumi.get(__ret__, 'flavor'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + options=pulumi.get(__ret__, 'options'), + project_id=pulumi.get(__ret__, 'project_id'), + replicas=pulumi.get(__ret__, 'replicas'), + storage=pulumi.get(__ret__, 'storage'), + version=pulumi.get(__ret__, 'version')) +def get_mongodbflex_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMongodbflexInstanceResult]: + """ + MongoDB Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MongoDB Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getMongodbflexInstance:getMongodbflexInstance', __args__, opts=opts, typ=GetMongodbflexInstanceResult) + return __ret__.apply(lambda __response__: GetMongodbflexInstanceResult( + acls=pulumi.get(__response__, 'acls'), + backup_schedule=pulumi.get(__response__, 'backup_schedule'), + flavor=pulumi.get(__response__, 'flavor'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + options=pulumi.get(__response__, 'options'), + project_id=pulumi.get(__response__, 'project_id'), + replicas=pulumi.get(__response__, 'replicas'), + storage=pulumi.get(__response__, 'storage'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_mongodbflex_user.py b/sdk/python/pulumi_stackit/get_mongodbflex_user.py new file mode 100644 index 0000000..bf2becc --- /dev/null +++ b/sdk/python/pulumi_stackit/get_mongodbflex_user.py @@ -0,0 +1,191 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetMongodbflexUserResult', + 'AwaitableGetMongodbflexUserResult', + 'get_mongodbflex_user', + 'get_mongodbflex_user_output', +] + +@pulumi.output_type +class GetMongodbflexUserResult: + """ + A collection of values returned by getMongodbflexUser. + """ + def __init__(__self__, database=None, host=None, id=None, instance_id=None, port=None, project_id=None, roles=None, user_id=None, username=None): + if database and not isinstance(database, str): + raise TypeError("Expected argument 'database' to be a str") + pulumi.set(__self__, "database", database) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if roles and not isinstance(roles, list): + raise TypeError("Expected argument 'roles' to be a list") + pulumi.set(__self__, "roles", roles) + if user_id and not isinstance(user_id, str): + raise TypeError("Expected argument 'user_id' to be a str") + pulumi.set(__self__, "user_id", user_id) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def database(self) -> builtins.str: + return pulumi.get(self, "database") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def roles(self) -> Sequence[builtins.str]: + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> builtins.str: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetMongodbflexUserResult(GetMongodbflexUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetMongodbflexUserResult( + database=self.database, + host=self.host, + id=self.id, + instance_id=self.instance_id, + port=self.port, + project_id=self.project_id, + roles=self.roles, + user_id=self.user_id, + username=self.username) + + +def get_mongodbflex_user(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + user_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMongodbflexUserResult: + """ + MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MongoDB Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getMongodbflexUser:getMongodbflexUser', __args__, opts=opts, typ=GetMongodbflexUserResult).value + + return AwaitableGetMongodbflexUserResult( + database=pulumi.get(__ret__, 'database'), + host=pulumi.get(__ret__, 'host'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + roles=pulumi.get(__ret__, 'roles'), + user_id=pulumi.get(__ret__, 'user_id'), + username=pulumi.get(__ret__, 'username')) +def get_mongodbflex_user_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetMongodbflexUserResult]: + """ + MongoDB Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the MongoDB Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getMongodbflexUser:getMongodbflexUser', __args__, opts=opts, typ=GetMongodbflexUserResult) + return __ret__.apply(lambda __response__: GetMongodbflexUserResult( + database=pulumi.get(__response__, 'database'), + host=pulumi.get(__response__, 'host'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + roles=pulumi.get(__response__, 'roles'), + user_id=pulumi.get(__response__, 'user_id'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_network.py b/sdk/python/pulumi_stackit/get_network.py new file mode 100644 index 0000000..e7d8698 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_network.py @@ -0,0 +1,344 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetNetworkResult', + 'AwaitableGetNetworkResult', + 'get_network', + 'get_network_output', +] + +@pulumi.output_type +class GetNetworkResult: + """ + A collection of values returned by getNetwork. + """ + def __init__(__self__, id=None, ipv4_gateway=None, ipv4_nameservers=None, ipv4_prefix=None, ipv4_prefix_length=None, ipv4_prefixes=None, ipv6_gateway=None, ipv6_nameservers=None, ipv6_prefix=None, ipv6_prefix_length=None, ipv6_prefixes=None, labels=None, name=None, nameservers=None, network_id=None, prefixes=None, project_id=None, public_ip=None, routed=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if ipv4_gateway and not isinstance(ipv4_gateway, str): + raise TypeError("Expected argument 'ipv4_gateway' to be a str") + pulumi.set(__self__, "ipv4_gateway", ipv4_gateway) + if ipv4_nameservers and not isinstance(ipv4_nameservers, list): + raise TypeError("Expected argument 'ipv4_nameservers' to be a list") + pulumi.set(__self__, "ipv4_nameservers", ipv4_nameservers) + if ipv4_prefix and not isinstance(ipv4_prefix, str): + raise TypeError("Expected argument 'ipv4_prefix' to be a str") + pulumi.set(__self__, "ipv4_prefix", ipv4_prefix) + if ipv4_prefix_length and not isinstance(ipv4_prefix_length, int): + raise TypeError("Expected argument 'ipv4_prefix_length' to be a int") + pulumi.set(__self__, "ipv4_prefix_length", ipv4_prefix_length) + if ipv4_prefixes and not isinstance(ipv4_prefixes, list): + raise TypeError("Expected argument 'ipv4_prefixes' to be a list") + pulumi.set(__self__, "ipv4_prefixes", ipv4_prefixes) + if ipv6_gateway and not isinstance(ipv6_gateway, str): + raise TypeError("Expected argument 'ipv6_gateway' to be a str") + pulumi.set(__self__, "ipv6_gateway", ipv6_gateway) + if ipv6_nameservers and not isinstance(ipv6_nameservers, list): + raise TypeError("Expected argument 'ipv6_nameservers' to be a list") + pulumi.set(__self__, "ipv6_nameservers", ipv6_nameservers) + if ipv6_prefix and not isinstance(ipv6_prefix, str): + raise TypeError("Expected argument 'ipv6_prefix' to be a str") + pulumi.set(__self__, "ipv6_prefix", ipv6_prefix) + if ipv6_prefix_length and not isinstance(ipv6_prefix_length, int): + raise TypeError("Expected argument 'ipv6_prefix_length' to be a int") + pulumi.set(__self__, "ipv6_prefix_length", ipv6_prefix_length) + if ipv6_prefixes and not isinstance(ipv6_prefixes, list): + raise TypeError("Expected argument 'ipv6_prefixes' to be a list") + pulumi.set(__self__, "ipv6_prefixes", ipv6_prefixes) + if labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + 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 nameservers and not isinstance(nameservers, list): + raise TypeError("Expected argument 'nameservers' to be a list") + pulumi.set(__self__, "nameservers", nameservers) + if network_id and not isinstance(network_id, str): + raise TypeError("Expected argument 'network_id' to be a str") + pulumi.set(__self__, "network_id", network_id) + if prefixes and not isinstance(prefixes, list): + raise TypeError("Expected argument 'prefixes' to be a list") + pulumi.set(__self__, "prefixes", prefixes) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if public_ip and not isinstance(public_ip, str): + raise TypeError("Expected argument 'public_ip' to be a str") + pulumi.set(__self__, "public_ip", public_ip) + if routed and not isinstance(routed, bool): + raise TypeError("Expected argument 'routed' to be a bool") + pulumi.set(__self__, "routed", routed) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="ipv4Gateway") + def ipv4_gateway(self) -> builtins.str: + """ + The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv4_gateway") + + @property + @pulumi.getter(name="ipv4Nameservers") + def ipv4_nameservers(self) -> Sequence[builtins.str]: + """ + The IPv4 nameservers of the network. + """ + return pulumi.get(self, "ipv4_nameservers") + + @property + @pulumi.getter(name="ipv4Prefix") + @_utilities.deprecated("""The API supports reading multiple prefixes. So using the attribute 'ipv4_prefixes` should be preferred. This attribute will be populated with the first element from the list""") + def ipv4_prefix(self) -> builtins.str: + """ + The IPv4 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv4_prefix") + + @property + @pulumi.getter(name="ipv4PrefixLength") + def ipv4_prefix_length(self) -> builtins.int: + """ + The IPv4 prefix length of the network. + """ + return pulumi.get(self, "ipv4_prefix_length") + + @property + @pulumi.getter(name="ipv4Prefixes") + def ipv4_prefixes(self) -> Sequence[builtins.str]: + """ + The IPv4 prefixes of the network. + """ + return pulumi.get(self, "ipv4_prefixes") + + @property + @pulumi.getter(name="ipv6Gateway") + def ipv6_gateway(self) -> builtins.str: + """ + The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv6_gateway") + + @property + @pulumi.getter(name="ipv6Nameservers") + def ipv6_nameservers(self) -> Sequence[builtins.str]: + """ + The IPv6 nameservers of the network. + """ + return pulumi.get(self, "ipv6_nameservers") + + @property + @pulumi.getter(name="ipv6Prefix") + @_utilities.deprecated("""The API supports reading multiple prefixes. So using the attribute 'ipv6_prefixes` should be preferred. This attribute will be populated with the first element from the list""") + def ipv6_prefix(self) -> builtins.str: + """ + The IPv6 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv6_prefix") + + @property + @pulumi.getter(name="ipv6PrefixLength") + def ipv6_prefix_length(self) -> builtins.int: + """ + The IPv6 prefix length of the network. + """ + return pulumi.get(self, "ipv6_prefix_length") + + @property + @pulumi.getter(name="ipv6Prefixes") + def ipv6_prefixes(self) -> Sequence[builtins.str]: + """ + The IPv6 prefixes of the network. + """ + return pulumi.get(self, "ipv6_prefixes") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the network. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + def nameservers(self) -> Sequence[builtins.str]: + """ + The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + """ + return pulumi.get(self, "nameservers") + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> builtins.str: + """ + The network ID. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.""") + def prefixes(self) -> Sequence[builtins.str]: + """ + The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + """ + return pulumi.get(self, "prefixes") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicIp") + def public_ip(self) -> builtins.str: + """ + The public IP of the network. + """ + return pulumi.get(self, "public_ip") + + @property + @pulumi.getter + def routed(self) -> builtins.bool: + """ + Shows if the network is routed and therefore accessible from other networks. + """ + return pulumi.get(self, "routed") + + +class AwaitableGetNetworkResult(GetNetworkResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetNetworkResult( + id=self.id, + ipv4_gateway=self.ipv4_gateway, + ipv4_nameservers=self.ipv4_nameservers, + ipv4_prefix=self.ipv4_prefix, + ipv4_prefix_length=self.ipv4_prefix_length, + ipv4_prefixes=self.ipv4_prefixes, + ipv6_gateway=self.ipv6_gateway, + ipv6_nameservers=self.ipv6_nameservers, + ipv6_prefix=self.ipv6_prefix, + ipv6_prefix_length=self.ipv6_prefix_length, + ipv6_prefixes=self.ipv6_prefixes, + labels=self.labels, + name=self.name, + nameservers=self.nameservers, + network_id=self.network_id, + prefixes=self.prefixes, + project_id=self.project_id, + public_ip=self.public_ip, + routed=self.routed) + + +def get_network(network_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkResult: + """ + Network resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_id: The network ID. + :param builtins.str project_id: STACKIT project ID to which the network is associated. + """ + __args__ = dict() + __args__['networkId'] = network_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getNetwork:getNetwork', __args__, opts=opts, typ=GetNetworkResult).value + + return AwaitableGetNetworkResult( + id=pulumi.get(__ret__, 'id'), + ipv4_gateway=pulumi.get(__ret__, 'ipv4_gateway'), + ipv4_nameservers=pulumi.get(__ret__, 'ipv4_nameservers'), + ipv4_prefix=pulumi.get(__ret__, 'ipv4_prefix'), + ipv4_prefix_length=pulumi.get(__ret__, 'ipv4_prefix_length'), + ipv4_prefixes=pulumi.get(__ret__, 'ipv4_prefixes'), + ipv6_gateway=pulumi.get(__ret__, 'ipv6_gateway'), + ipv6_nameservers=pulumi.get(__ret__, 'ipv6_nameservers'), + ipv6_prefix=pulumi.get(__ret__, 'ipv6_prefix'), + ipv6_prefix_length=pulumi.get(__ret__, 'ipv6_prefix_length'), + ipv6_prefixes=pulumi.get(__ret__, 'ipv6_prefixes'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + nameservers=pulumi.get(__ret__, 'nameservers'), + network_id=pulumi.get(__ret__, 'network_id'), + prefixes=pulumi.get(__ret__, 'prefixes'), + project_id=pulumi.get(__ret__, 'project_id'), + public_ip=pulumi.get(__ret__, 'public_ip'), + routed=pulumi.get(__ret__, 'routed')) +def get_network_output(network_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNetworkResult]: + """ + Network resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_id: The network ID. + :param builtins.str project_id: STACKIT project ID to which the network is associated. + """ + __args__ = dict() + __args__['networkId'] = network_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getNetwork:getNetwork', __args__, opts=opts, typ=GetNetworkResult) + return __ret__.apply(lambda __response__: GetNetworkResult( + id=pulumi.get(__response__, 'id'), + ipv4_gateway=pulumi.get(__response__, 'ipv4_gateway'), + ipv4_nameservers=pulumi.get(__response__, 'ipv4_nameservers'), + ipv4_prefix=pulumi.get(__response__, 'ipv4_prefix'), + ipv4_prefix_length=pulumi.get(__response__, 'ipv4_prefix_length'), + ipv4_prefixes=pulumi.get(__response__, 'ipv4_prefixes'), + ipv6_gateway=pulumi.get(__response__, 'ipv6_gateway'), + ipv6_nameservers=pulumi.get(__response__, 'ipv6_nameservers'), + ipv6_prefix=pulumi.get(__response__, 'ipv6_prefix'), + ipv6_prefix_length=pulumi.get(__response__, 'ipv6_prefix_length'), + ipv6_prefixes=pulumi.get(__response__, 'ipv6_prefixes'), + labels=pulumi.get(__response__, 'labels'), + name=pulumi.get(__response__, 'name'), + nameservers=pulumi.get(__response__, 'nameservers'), + network_id=pulumi.get(__response__, 'network_id'), + prefixes=pulumi.get(__response__, 'prefixes'), + project_id=pulumi.get(__response__, 'project_id'), + public_ip=pulumi.get(__response__, 'public_ip'), + routed=pulumi.get(__response__, 'routed'))) diff --git a/sdk/python/pulumi_stackit/get_network_area.py b/sdk/python/pulumi_stackit/get_network_area.py new file mode 100644 index 0000000..fa95264 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_network_area.py @@ -0,0 +1,243 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetNetworkAreaResult', + 'AwaitableGetNetworkAreaResult', + 'get_network_area', + 'get_network_area_output', +] + +@pulumi.output_type +class GetNetworkAreaResult: + """ + A collection of values returned by getNetworkArea. + """ + def __init__(__self__, default_nameservers=None, default_prefix_length=None, id=None, labels=None, max_prefix_length=None, min_prefix_length=None, name=None, network_area_id=None, network_ranges=None, organization_id=None, project_count=None, transfer_network=None): + if default_nameservers and not isinstance(default_nameservers, list): + raise TypeError("Expected argument 'default_nameservers' to be a list") + pulumi.set(__self__, "default_nameservers", default_nameservers) + if default_prefix_length and not isinstance(default_prefix_length, int): + raise TypeError("Expected argument 'default_prefix_length' to be a int") + pulumi.set(__self__, "default_prefix_length", default_prefix_length) + 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, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if max_prefix_length and not isinstance(max_prefix_length, int): + raise TypeError("Expected argument 'max_prefix_length' to be a int") + pulumi.set(__self__, "max_prefix_length", max_prefix_length) + if min_prefix_length and not isinstance(min_prefix_length, int): + raise TypeError("Expected argument 'min_prefix_length' to be a int") + pulumi.set(__self__, "min_prefix_length", min_prefix_length) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if network_area_id and not isinstance(network_area_id, str): + raise TypeError("Expected argument 'network_area_id' to be a str") + pulumi.set(__self__, "network_area_id", network_area_id) + if network_ranges and not isinstance(network_ranges, list): + raise TypeError("Expected argument 'network_ranges' to be a list") + pulumi.set(__self__, "network_ranges", network_ranges) + if organization_id and not isinstance(organization_id, str): + raise TypeError("Expected argument 'organization_id' to be a str") + pulumi.set(__self__, "organization_id", organization_id) + if project_count and not isinstance(project_count, int): + raise TypeError("Expected argument 'project_count' to be a int") + pulumi.set(__self__, "project_count", project_count) + if transfer_network and not isinstance(transfer_network, str): + raise TypeError("Expected argument 'transfer_network' to be a str") + pulumi.set(__self__, "transfer_network", transfer_network) + + @property + @pulumi.getter(name="defaultNameservers") + def default_nameservers(self) -> Sequence[builtins.str]: + """ + List of DNS Servers/Nameservers. + """ + return pulumi.get(self, "default_nameservers") + + @property + @pulumi.getter(name="defaultPrefixLength") + def default_prefix_length(self) -> builtins.int: + """ + The default prefix length for networks in the network area. + """ + return pulumi.get(self, "default_prefix_length") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="maxPrefixLength") + def max_prefix_length(self) -> builtins.int: + """ + The maximal prefix length for networks in the network area. + """ + return pulumi.get(self, "max_prefix_length") + + @property + @pulumi.getter(name="minPrefixLength") + def min_prefix_length(self) -> builtins.int: + """ + The minimal prefix length for networks in the network area. + """ + return pulumi.get(self, "min_prefix_length") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the network area. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> builtins.str: + """ + The network area ID. + """ + return pulumi.get(self, "network_area_id") + + @property + @pulumi.getter(name="networkRanges") + def network_ranges(self) -> Sequence['outputs.GetNetworkAreaNetworkRangeResult']: + """ + List of Network ranges. + """ + return pulumi.get(self, "network_ranges") + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> builtins.str: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @property + @pulumi.getter(name="projectCount") + def project_count(self) -> builtins.int: + """ + The amount of projects currently referencing this area. + """ + return pulumi.get(self, "project_count") + + @property + @pulumi.getter(name="transferNetwork") + def transfer_network(self) -> builtins.str: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "transfer_network") + + +class AwaitableGetNetworkAreaResult(GetNetworkAreaResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetNetworkAreaResult( + default_nameservers=self.default_nameservers, + default_prefix_length=self.default_prefix_length, + id=self.id, + labels=self.labels, + max_prefix_length=self.max_prefix_length, + min_prefix_length=self.min_prefix_length, + name=self.name, + network_area_id=self.network_area_id, + network_ranges=self.network_ranges, + organization_id=self.organization_id, + project_count=self.project_count, + transfer_network=self.transfer_network) + + +def get_network_area(network_area_id: Optional[builtins.str] = None, + organization_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkAreaResult: + """ + Network area datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_area_id: The network area ID. + :param builtins.str organization_id: STACKIT organization ID to which the network area is associated. + """ + __args__ = dict() + __args__['networkAreaId'] = network_area_id + __args__['organizationId'] = organization_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getNetworkArea:getNetworkArea', __args__, opts=opts, typ=GetNetworkAreaResult).value + + return AwaitableGetNetworkAreaResult( + default_nameservers=pulumi.get(__ret__, 'default_nameservers'), + default_prefix_length=pulumi.get(__ret__, 'default_prefix_length'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + max_prefix_length=pulumi.get(__ret__, 'max_prefix_length'), + min_prefix_length=pulumi.get(__ret__, 'min_prefix_length'), + name=pulumi.get(__ret__, 'name'), + network_area_id=pulumi.get(__ret__, 'network_area_id'), + network_ranges=pulumi.get(__ret__, 'network_ranges'), + organization_id=pulumi.get(__ret__, 'organization_id'), + project_count=pulumi.get(__ret__, 'project_count'), + transfer_network=pulumi.get(__ret__, 'transfer_network')) +def get_network_area_output(network_area_id: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNetworkAreaResult]: + """ + Network area datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_area_id: The network area ID. + :param builtins.str organization_id: STACKIT organization ID to which the network area is associated. + """ + __args__ = dict() + __args__['networkAreaId'] = network_area_id + __args__['organizationId'] = organization_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getNetworkArea:getNetworkArea', __args__, opts=opts, typ=GetNetworkAreaResult) + return __ret__.apply(lambda __response__: GetNetworkAreaResult( + default_nameservers=pulumi.get(__response__, 'default_nameservers'), + default_prefix_length=pulumi.get(__response__, 'default_prefix_length'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + max_prefix_length=pulumi.get(__response__, 'max_prefix_length'), + min_prefix_length=pulumi.get(__response__, 'min_prefix_length'), + name=pulumi.get(__response__, 'name'), + network_area_id=pulumi.get(__response__, 'network_area_id'), + network_ranges=pulumi.get(__response__, 'network_ranges'), + organization_id=pulumi.get(__response__, 'organization_id'), + project_count=pulumi.get(__response__, 'project_count'), + transfer_network=pulumi.get(__response__, 'transfer_network'))) diff --git a/sdk/python/pulumi_stackit/get_network_area_route.py b/sdk/python/pulumi_stackit/get_network_area_route.py new file mode 100644 index 0000000..767b52d --- /dev/null +++ b/sdk/python/pulumi_stackit/get_network_area_route.py @@ -0,0 +1,178 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetNetworkAreaRouteResult', + 'AwaitableGetNetworkAreaRouteResult', + 'get_network_area_route', + 'get_network_area_route_output', +] + +@pulumi.output_type +class GetNetworkAreaRouteResult: + """ + A collection of values returned by getNetworkAreaRoute. + """ + def __init__(__self__, id=None, labels=None, network_area_id=None, network_area_route_id=None, next_hop=None, organization_id=None, prefix=None): + 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, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if network_area_id and not isinstance(network_area_id, str): + raise TypeError("Expected argument 'network_area_id' to be a str") + pulumi.set(__self__, "network_area_id", network_area_id) + if network_area_route_id and not isinstance(network_area_route_id, str): + raise TypeError("Expected argument 'network_area_route_id' to be a str") + pulumi.set(__self__, "network_area_route_id", network_area_route_id) + if next_hop and not isinstance(next_hop, str): + raise TypeError("Expected argument 'next_hop' to be a str") + pulumi.set(__self__, "next_hop", next_hop) + if organization_id and not isinstance(organization_id, str): + raise TypeError("Expected argument 'organization_id' to be a str") + pulumi.set(__self__, "organization_id", organization_id) + if prefix and not isinstance(prefix, str): + raise TypeError("Expected argument 'prefix' to be a str") + pulumi.set(__self__, "prefix", prefix) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> builtins.str: + """ + The network area ID to which the network area route is associated. + """ + return pulumi.get(self, "network_area_id") + + @property + @pulumi.getter(name="networkAreaRouteId") + def network_area_route_id(self) -> builtins.str: + """ + The network area route ID. + """ + return pulumi.get(self, "network_area_route_id") + + @property + @pulumi.getter(name="nextHop") + def next_hop(self) -> builtins.str: + """ + The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + """ + return pulumi.get(self, "next_hop") + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> builtins.str: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @property + @pulumi.getter + def prefix(self) -> builtins.str: + """ + The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + return pulumi.get(self, "prefix") + + +class AwaitableGetNetworkAreaRouteResult(GetNetworkAreaRouteResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetNetworkAreaRouteResult( + id=self.id, + labels=self.labels, + network_area_id=self.network_area_id, + network_area_route_id=self.network_area_route_id, + next_hop=self.next_hop, + organization_id=self.organization_id, + prefix=self.prefix) + + +def get_network_area_route(network_area_id: Optional[builtins.str] = None, + network_area_route_id: Optional[builtins.str] = None, + organization_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkAreaRouteResult: + """ + Network area route data resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_area_id: The network area ID to which the network area route is associated. + :param builtins.str network_area_route_id: The network area route ID. + :param builtins.str organization_id: STACKIT organization ID to which the network area is associated. + """ + __args__ = dict() + __args__['networkAreaId'] = network_area_id + __args__['networkAreaRouteId'] = network_area_route_id + __args__['organizationId'] = organization_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getNetworkAreaRoute:getNetworkAreaRoute', __args__, opts=opts, typ=GetNetworkAreaRouteResult).value + + return AwaitableGetNetworkAreaRouteResult( + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + network_area_id=pulumi.get(__ret__, 'network_area_id'), + network_area_route_id=pulumi.get(__ret__, 'network_area_route_id'), + next_hop=pulumi.get(__ret__, 'next_hop'), + organization_id=pulumi.get(__ret__, 'organization_id'), + prefix=pulumi.get(__ret__, 'prefix')) +def get_network_area_route_output(network_area_id: Optional[pulumi.Input[builtins.str]] = None, + network_area_route_id: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNetworkAreaRouteResult]: + """ + Network area route data resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_area_id: The network area ID to which the network area route is associated. + :param builtins.str network_area_route_id: The network area route ID. + :param builtins.str organization_id: STACKIT organization ID to which the network area is associated. + """ + __args__ = dict() + __args__['networkAreaId'] = network_area_id + __args__['networkAreaRouteId'] = network_area_route_id + __args__['organizationId'] = organization_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getNetworkAreaRoute:getNetworkAreaRoute', __args__, opts=opts, typ=GetNetworkAreaRouteResult) + return __ret__.apply(lambda __response__: GetNetworkAreaRouteResult( + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + network_area_id=pulumi.get(__response__, 'network_area_id'), + network_area_route_id=pulumi.get(__response__, 'network_area_route_id'), + next_hop=pulumi.get(__response__, 'next_hop'), + organization_id=pulumi.get(__response__, 'organization_id'), + prefix=pulumi.get(__response__, 'prefix'))) diff --git a/sdk/python/pulumi_stackit/get_network_interface.py b/sdk/python/pulumi_stackit/get_network_interface.py new file mode 100644 index 0000000..19e2464 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_network_interface.py @@ -0,0 +1,262 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetNetworkInterfaceResult', + 'AwaitableGetNetworkInterfaceResult', + 'get_network_interface', + 'get_network_interface_output', +] + +@pulumi.output_type +class GetNetworkInterfaceResult: + """ + A collection of values returned by getNetworkInterface. + """ + def __init__(__self__, allowed_addresses=None, device=None, id=None, ipv4=None, labels=None, mac=None, name=None, network_id=None, network_interface_id=None, project_id=None, security=None, security_group_ids=None, type=None): + if allowed_addresses and not isinstance(allowed_addresses, list): + raise TypeError("Expected argument 'allowed_addresses' to be a list") + pulumi.set(__self__, "allowed_addresses", allowed_addresses) + if device and not isinstance(device, str): + raise TypeError("Expected argument 'device' to be a str") + pulumi.set(__self__, "device", device) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if ipv4 and not isinstance(ipv4, str): + raise TypeError("Expected argument 'ipv4' to be a str") + pulumi.set(__self__, "ipv4", ipv4) + if labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if mac and not isinstance(mac, str): + raise TypeError("Expected argument 'mac' to be a str") + pulumi.set(__self__, "mac", mac) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if network_id and not isinstance(network_id, str): + raise TypeError("Expected argument 'network_id' to be a str") + pulumi.set(__self__, "network_id", network_id) + if network_interface_id and not isinstance(network_interface_id, str): + raise TypeError("Expected argument 'network_interface_id' to be a str") + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if security and not isinstance(security, bool): + raise TypeError("Expected argument 'security' to be a bool") + pulumi.set(__self__, "security", security) + if security_group_ids and not isinstance(security_group_ids, list): + raise TypeError("Expected argument 'security_group_ids' to be a list") + pulumi.set(__self__, "security_group_ids", security_group_ids) + if type and not isinstance(type, str): + raise TypeError("Expected argument 'type' to be a str") + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter(name="allowedAddresses") + def allowed_addresses(self) -> Sequence[builtins.str]: + """ + The list of CIDR (Classless Inter-Domain Routing) notations. + """ + return pulumi.get(self, "allowed_addresses") + + @property + @pulumi.getter + def device(self) -> builtins.str: + """ + The device UUID of the network interface. + """ + return pulumi.get(self, "device") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def ipv4(self) -> builtins.str: + """ + The IPv4 address. + """ + return pulumi.get(self, "ipv4") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a network interface. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def mac(self) -> builtins.str: + """ + The MAC address of network interface. + """ + return pulumi.get(self, "mac") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the network interface. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> builtins.str: + """ + The network ID to which the network interface is associated. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> builtins.str: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the network interface is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def security(self) -> builtins.bool: + """ + The Network Interface Security. If set to false, then no security groups will apply to this network interface. + """ + return pulumi.get(self, "security") + + @property + @pulumi.getter(name="securityGroupIds") + def security_group_ids(self) -> Sequence[builtins.str]: + """ + The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + return pulumi.get(self, "security_group_ids") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + """ + return pulumi.get(self, "type") + + +class AwaitableGetNetworkInterfaceResult(GetNetworkInterfaceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetNetworkInterfaceResult( + allowed_addresses=self.allowed_addresses, + device=self.device, + id=self.id, + ipv4=self.ipv4, + labels=self.labels, + mac=self.mac, + name=self.name, + network_id=self.network_id, + network_interface_id=self.network_interface_id, + project_id=self.project_id, + security=self.security, + security_group_ids=self.security_group_ids, + type=self.type) + + +def get_network_interface(network_id: Optional[builtins.str] = None, + network_interface_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNetworkInterfaceResult: + """ + Network interface datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_id: The network ID to which the network interface is associated. + :param builtins.str network_interface_id: The network interface ID. + :param builtins.str project_id: STACKIT project ID to which the network interface is associated. + """ + __args__ = dict() + __args__['networkId'] = network_id + __args__['networkInterfaceId'] = network_interface_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getNetworkInterface:getNetworkInterface', __args__, opts=opts, typ=GetNetworkInterfaceResult).value + + return AwaitableGetNetworkInterfaceResult( + allowed_addresses=pulumi.get(__ret__, 'allowed_addresses'), + device=pulumi.get(__ret__, 'device'), + id=pulumi.get(__ret__, 'id'), + ipv4=pulumi.get(__ret__, 'ipv4'), + labels=pulumi.get(__ret__, 'labels'), + mac=pulumi.get(__ret__, 'mac'), + name=pulumi.get(__ret__, 'name'), + network_id=pulumi.get(__ret__, 'network_id'), + network_interface_id=pulumi.get(__ret__, 'network_interface_id'), + project_id=pulumi.get(__ret__, 'project_id'), + security=pulumi.get(__ret__, 'security'), + security_group_ids=pulumi.get(__ret__, 'security_group_ids'), + type=pulumi.get(__ret__, 'type')) +def get_network_interface_output(network_id: Optional[pulumi.Input[builtins.str]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNetworkInterfaceResult]: + """ + Network interface datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str network_id: The network ID to which the network interface is associated. + :param builtins.str network_interface_id: The network interface ID. + :param builtins.str project_id: STACKIT project ID to which the network interface is associated. + """ + __args__ = dict() + __args__['networkId'] = network_id + __args__['networkInterfaceId'] = network_interface_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getNetworkInterface:getNetworkInterface', __args__, opts=opts, typ=GetNetworkInterfaceResult) + return __ret__.apply(lambda __response__: GetNetworkInterfaceResult( + allowed_addresses=pulumi.get(__response__, 'allowed_addresses'), + device=pulumi.get(__response__, 'device'), + id=pulumi.get(__response__, 'id'), + ipv4=pulumi.get(__response__, 'ipv4'), + labels=pulumi.get(__response__, 'labels'), + mac=pulumi.get(__response__, 'mac'), + name=pulumi.get(__response__, 'name'), + network_id=pulumi.get(__response__, 'network_id'), + network_interface_id=pulumi.get(__response__, 'network_interface_id'), + project_id=pulumi.get(__response__, 'project_id'), + security=pulumi.get(__response__, 'security'), + security_group_ids=pulumi.get(__response__, 'security_group_ids'), + type=pulumi.get(__response__, 'type'))) diff --git a/sdk/python/pulumi_stackit/get_objectstorage_bucket.py b/sdk/python/pulumi_stackit/get_objectstorage_bucket.py new file mode 100644 index 0000000..fe61644 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_objectstorage_bucket.py @@ -0,0 +1,158 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetObjectstorageBucketResult', + 'AwaitableGetObjectstorageBucketResult', + 'get_objectstorage_bucket', + 'get_objectstorage_bucket_output', +] + +@pulumi.output_type +class GetObjectstorageBucketResult: + """ + A collection of values returned by getObjectstorageBucket. + """ + def __init__(__self__, id=None, name=None, project_id=None, region=None, url_path_style=None, url_virtual_hosted_style=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if url_path_style and not isinstance(url_path_style, str): + raise TypeError("Expected argument 'url_path_style' to be a str") + pulumi.set(__self__, "url_path_style", url_path_style) + if url_virtual_hosted_style and not isinstance(url_virtual_hosted_style, str): + raise TypeError("Expected argument 'url_virtual_hosted_style' to be a str") + pulumi.set(__self__, "url_virtual_hosted_style", url_virtual_hosted_style) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The bucket name. It must be DNS conform. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the bucket is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="urlPathStyle") + def url_path_style(self) -> builtins.str: + return pulumi.get(self, "url_path_style") + + @property + @pulumi.getter(name="urlVirtualHostedStyle") + def url_virtual_hosted_style(self) -> builtins.str: + return pulumi.get(self, "url_virtual_hosted_style") + + +class AwaitableGetObjectstorageBucketResult(GetObjectstorageBucketResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObjectstorageBucketResult( + id=self.id, + name=self.name, + project_id=self.project_id, + region=self.region, + url_path_style=self.url_path_style, + url_virtual_hosted_style=self.url_virtual_hosted_style) + + +def get_objectstorage_bucket(name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObjectstorageBucketResult: + """ + ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The bucket name. It must be DNS conform. + :param builtins.str project_id: STACKIT Project ID to which the bucket is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObjectstorageBucket:getObjectstorageBucket', __args__, opts=opts, typ=GetObjectstorageBucketResult).value + + return AwaitableGetObjectstorageBucketResult( + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + url_path_style=pulumi.get(__ret__, 'url_path_style'), + url_virtual_hosted_style=pulumi.get(__ret__, 'url_virtual_hosted_style')) +def get_objectstorage_bucket_output(name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObjectstorageBucketResult]: + """ + ObjectStorage bucket data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The bucket name. It must be DNS conform. + :param builtins.str project_id: STACKIT Project ID to which the bucket is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObjectstorageBucket:getObjectstorageBucket', __args__, opts=opts, typ=GetObjectstorageBucketResult) + return __ret__.apply(lambda __response__: GetObjectstorageBucketResult( + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + url_path_style=pulumi.get(__response__, 'url_path_style'), + url_virtual_hosted_style=pulumi.get(__response__, 'url_virtual_hosted_style'))) diff --git a/sdk/python/pulumi_stackit/get_objectstorage_credential.py b/sdk/python/pulumi_stackit/get_objectstorage_credential.py new file mode 100644 index 0000000..f1c838e --- /dev/null +++ b/sdk/python/pulumi_stackit/get_objectstorage_credential.py @@ -0,0 +1,178 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetObjectstorageCredentialResult', + 'AwaitableGetObjectstorageCredentialResult', + 'get_objectstorage_credential', + 'get_objectstorage_credential_output', +] + +@pulumi.output_type +class GetObjectstorageCredentialResult: + """ + A collection of values returned by getObjectstorageCredential. + """ + def __init__(__self__, credential_id=None, credentials_group_id=None, expiration_timestamp=None, id=None, name=None, project_id=None, region=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if credentials_group_id and not isinstance(credentials_group_id, str): + raise TypeError("Expected argument 'credentials_group_id' to be a str") + pulumi.set(__self__, "credentials_group_id", credentials_group_id) + if expiration_timestamp and not isinstance(expiration_timestamp, str): + raise TypeError("Expected argument 'expiration_timestamp' to be a str") + pulumi.set(__self__, "expiration_timestamp", expiration_timestamp) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> builtins.str: + """ + The credential group ID. + """ + return pulumi.get(self, "credentials_group_id") + + @property + @pulumi.getter(name="expirationTimestamp") + def expiration_timestamp(self) -> builtins.str: + return pulumi.get(self, "expiration_timestamp") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the credential group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + +class AwaitableGetObjectstorageCredentialResult(GetObjectstorageCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObjectstorageCredentialResult( + credential_id=self.credential_id, + credentials_group_id=self.credentials_group_id, + expiration_timestamp=self.expiration_timestamp, + id=self.id, + name=self.name, + project_id=self.project_id, + region=self.region) + + +def get_objectstorage_credential(credential_id: Optional[builtins.str] = None, + credentials_group_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObjectstorageCredentialResult: + """ + ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential ID. + :param builtins.str credentials_group_id: The credential group ID. + :param builtins.str project_id: STACKIT Project ID to which the credential group is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['credentialsGroupId'] = credentials_group_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObjectstorageCredential:getObjectstorageCredential', __args__, opts=opts, typ=GetObjectstorageCredentialResult).value + + return AwaitableGetObjectstorageCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + credentials_group_id=pulumi.get(__ret__, 'credentials_group_id'), + expiration_timestamp=pulumi.get(__ret__, 'expiration_timestamp'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region')) +def get_objectstorage_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObjectstorageCredentialResult]: + """ + ObjectStorage credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential ID. + :param builtins.str credentials_group_id: The credential group ID. + :param builtins.str project_id: STACKIT Project ID to which the credential group is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['credentialsGroupId'] = credentials_group_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObjectstorageCredential:getObjectstorageCredential', __args__, opts=opts, typ=GetObjectstorageCredentialResult) + return __ret__.apply(lambda __response__: GetObjectstorageCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + credentials_group_id=pulumi.get(__response__, 'credentials_group_id'), + expiration_timestamp=pulumi.get(__response__, 'expiration_timestamp'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'))) diff --git a/sdk/python/pulumi_stackit/get_objectstorage_credentials_group.py b/sdk/python/pulumi_stackit/get_objectstorage_credentials_group.py new file mode 100644 index 0000000..c5c22c1 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_objectstorage_credentials_group.py @@ -0,0 +1,164 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetObjectstorageCredentialsGroupResult', + 'AwaitableGetObjectstorageCredentialsGroupResult', + 'get_objectstorage_credentials_group', + 'get_objectstorage_credentials_group_output', +] + +@pulumi.output_type +class GetObjectstorageCredentialsGroupResult: + """ + A collection of values returned by getObjectstorageCredentialsGroup. + """ + def __init__(__self__, credentials_group_id=None, id=None, name=None, project_id=None, region=None, urn=None): + if credentials_group_id and not isinstance(credentials_group_id, str): + raise TypeError("Expected argument 'credentials_group_id' to be a str") + pulumi.set(__self__, "credentials_group_id", credentials_group_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if urn and not isinstance(urn, str): + raise TypeError("Expected argument 'urn' to be a str") + pulumi.set(__self__, "urn", urn) + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> builtins.str: + """ + The credentials group ID. + """ + return pulumi.get(self, "credentials_group_id") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The credentials group's display name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + Object Storage Project ID to which the credentials group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def urn(self) -> builtins.str: + """ + Credentials group uniform resource name (URN) + """ + return pulumi.get(self, "urn") + + +class AwaitableGetObjectstorageCredentialsGroupResult(GetObjectstorageCredentialsGroupResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObjectstorageCredentialsGroupResult( + credentials_group_id=self.credentials_group_id, + id=self.id, + name=self.name, + project_id=self.project_id, + region=self.region, + urn=self.urn) + + +def get_objectstorage_credentials_group(credentials_group_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObjectstorageCredentialsGroupResult: + """ + ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credentials_group_id: The credentials group ID. + :param builtins.str project_id: Object Storage Project ID to which the credentials group is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['credentialsGroupId'] = credentials_group_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup', __args__, opts=opts, typ=GetObjectstorageCredentialsGroupResult).value + + return AwaitableGetObjectstorageCredentialsGroupResult( + credentials_group_id=pulumi.get(__ret__, 'credentials_group_id'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + urn=pulumi.get(__ret__, 'urn')) +def get_objectstorage_credentials_group_output(credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObjectstorageCredentialsGroupResult]: + """ + ObjectStorage credentials group data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credentials_group_id: The credentials group ID. + :param builtins.str project_id: Object Storage Project ID to which the credentials group is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['credentialsGroupId'] = credentials_group_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObjectstorageCredentialsGroup:getObjectstorageCredentialsGroup', __args__, opts=opts, typ=GetObjectstorageCredentialsGroupResult) + return __ret__.apply(lambda __response__: GetObjectstorageCredentialsGroupResult( + credentials_group_id=pulumi.get(__response__, 'credentials_group_id'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + urn=pulumi.get(__response__, 'urn'))) diff --git a/sdk/python/pulumi_stackit/get_observability_alertgroup.py b/sdk/python/pulumi_stackit/get_observability_alertgroup.py new file mode 100644 index 0000000..ab2d4d0 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_observability_alertgroup.py @@ -0,0 +1,162 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetObservabilityAlertgroupResult', + 'AwaitableGetObservabilityAlertgroupResult', + 'get_observability_alertgroup', + 'get_observability_alertgroup_output', +] + +@pulumi.output_type +class GetObservabilityAlertgroupResult: + """ + A collection of values returned by getObservabilityAlertgroup. + """ + def __init__(__self__, id=None, instance_id=None, interval=None, name=None, project_id=None, rules=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if interval and not isinstance(interval, str): + raise TypeError("Expected argument 'interval' to be a str") + pulumi.set(__self__, "interval", interval) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if rules and not isinstance(rules, list): + raise TypeError("Expected argument 'rules' to be a list") + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + Observability instance ID to which the alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def interval(self) -> builtins.str: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the alert group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def rules(self) -> Sequence['outputs.GetObservabilityAlertgroupRuleResult']: + return pulumi.get(self, "rules") + + +class AwaitableGetObservabilityAlertgroupResult(GetObservabilityAlertgroupResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObservabilityAlertgroupResult( + id=self.id, + instance_id=self.instance_id, + interval=self.interval, + name=self.name, + project_id=self.project_id, + rules=self.rules) + + +def get_observability_alertgroup(instance_id: Optional[builtins.str] = None, + name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObservabilityAlertgroupResult: + """ + Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the alert group is associated. + :param builtins.str name: The name of the alert group. Is the identifier and must be unique in the group. + :param builtins.str project_id: STACKIT project ID to which the alert group is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup', __args__, opts=opts, typ=GetObservabilityAlertgroupResult).value + + return AwaitableGetObservabilityAlertgroupResult( + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + interval=pulumi.get(__ret__, 'interval'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + rules=pulumi.get(__ret__, 'rules')) +def get_observability_alertgroup_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObservabilityAlertgroupResult]: + """ + Observability alert group datasource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the alert group is associated. + :param builtins.str name: The name of the alert group. Is the identifier and must be unique in the group. + :param builtins.str project_id: STACKIT project ID to which the alert group is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObservabilityAlertgroup:getObservabilityAlertgroup', __args__, opts=opts, typ=GetObservabilityAlertgroupResult) + return __ret__.apply(lambda __response__: GetObservabilityAlertgroupResult( + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + interval=pulumi.get(__response__, 'interval'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + rules=pulumi.get(__response__, 'rules'))) diff --git a/sdk/python/pulumi_stackit/get_observability_instance.py b/sdk/python/pulumi_stackit/get_observability_instance.py new file mode 100644 index 0000000..ab1f886 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_observability_instance.py @@ -0,0 +1,455 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetObservabilityInstanceResult', + 'AwaitableGetObservabilityInstanceResult', + 'get_observability_instance', + 'get_observability_instance_output', +] + +@pulumi.output_type +class GetObservabilityInstanceResult: + """ + A collection of values returned by getObservabilityInstance. + """ + def __init__(__self__, acls=None, alert_config=None, alerting_url=None, dashboard_url=None, grafana_initial_admin_password=None, grafana_initial_admin_user=None, grafana_public_read_access=None, grafana_url=None, id=None, instance_id=None, is_updatable=None, jaeger_traces_url=None, jaeger_ui_url=None, logs_push_url=None, logs_url=None, metrics_push_url=None, metrics_retention_days=None, metrics_retention_days1h_downsampling=None, metrics_retention_days5m_downsampling=None, metrics_url=None, name=None, otlp_traces_url=None, parameters=None, plan_id=None, plan_name=None, project_id=None, targets_url=None, zipkin_spans_url=None): + if acls and not isinstance(acls, list): + raise TypeError("Expected argument 'acls' to be a list") + pulumi.set(__self__, "acls", acls) + if alert_config and not isinstance(alert_config, dict): + raise TypeError("Expected argument 'alert_config' to be a dict") + pulumi.set(__self__, "alert_config", alert_config) + if alerting_url and not isinstance(alerting_url, str): + raise TypeError("Expected argument 'alerting_url' to be a str") + pulumi.set(__self__, "alerting_url", alerting_url) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if grafana_initial_admin_password and not isinstance(grafana_initial_admin_password, str): + raise TypeError("Expected argument 'grafana_initial_admin_password' to be a str") + pulumi.set(__self__, "grafana_initial_admin_password", grafana_initial_admin_password) + if grafana_initial_admin_user and not isinstance(grafana_initial_admin_user, str): + raise TypeError("Expected argument 'grafana_initial_admin_user' to be a str") + pulumi.set(__self__, "grafana_initial_admin_user", grafana_initial_admin_user) + if grafana_public_read_access and not isinstance(grafana_public_read_access, bool): + raise TypeError("Expected argument 'grafana_public_read_access' to be a bool") + pulumi.set(__self__, "grafana_public_read_access", grafana_public_read_access) + if grafana_url and not isinstance(grafana_url, str): + raise TypeError("Expected argument 'grafana_url' to be a str") + pulumi.set(__self__, "grafana_url", grafana_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if is_updatable and not isinstance(is_updatable, bool): + raise TypeError("Expected argument 'is_updatable' to be a bool") + pulumi.set(__self__, "is_updatable", is_updatable) + if jaeger_traces_url and not isinstance(jaeger_traces_url, str): + raise TypeError("Expected argument 'jaeger_traces_url' to be a str") + pulumi.set(__self__, "jaeger_traces_url", jaeger_traces_url) + if jaeger_ui_url and not isinstance(jaeger_ui_url, str): + raise TypeError("Expected argument 'jaeger_ui_url' to be a str") + pulumi.set(__self__, "jaeger_ui_url", jaeger_ui_url) + if logs_push_url and not isinstance(logs_push_url, str): + raise TypeError("Expected argument 'logs_push_url' to be a str") + pulumi.set(__self__, "logs_push_url", logs_push_url) + if logs_url and not isinstance(logs_url, str): + raise TypeError("Expected argument 'logs_url' to be a str") + pulumi.set(__self__, "logs_url", logs_url) + if metrics_push_url and not isinstance(metrics_push_url, str): + raise TypeError("Expected argument 'metrics_push_url' to be a str") + pulumi.set(__self__, "metrics_push_url", metrics_push_url) + if metrics_retention_days and not isinstance(metrics_retention_days, int): + raise TypeError("Expected argument 'metrics_retention_days' to be a int") + pulumi.set(__self__, "metrics_retention_days", metrics_retention_days) + if metrics_retention_days1h_downsampling and not isinstance(metrics_retention_days1h_downsampling, int): + raise TypeError("Expected argument 'metrics_retention_days1h_downsampling' to be a int") + pulumi.set(__self__, "metrics_retention_days1h_downsampling", metrics_retention_days1h_downsampling) + if metrics_retention_days5m_downsampling and not isinstance(metrics_retention_days5m_downsampling, int): + raise TypeError("Expected argument 'metrics_retention_days5m_downsampling' to be a int") + pulumi.set(__self__, "metrics_retention_days5m_downsampling", metrics_retention_days5m_downsampling) + if metrics_url and not isinstance(metrics_url, str): + raise TypeError("Expected argument 'metrics_url' to be a str") + pulumi.set(__self__, "metrics_url", metrics_url) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if otlp_traces_url and not isinstance(otlp_traces_url, str): + raise TypeError("Expected argument 'otlp_traces_url' to be a str") + pulumi.set(__self__, "otlp_traces_url", otlp_traces_url) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if targets_url and not isinstance(targets_url, str): + raise TypeError("Expected argument 'targets_url' to be a str") + pulumi.set(__self__, "targets_url", targets_url) + if zipkin_spans_url and not isinstance(zipkin_spans_url, str): + raise TypeError("Expected argument 'zipkin_spans_url' to be a str") + pulumi.set(__self__, "zipkin_spans_url", zipkin_spans_url) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="alertConfig") + def alert_config(self) -> 'outputs.GetObservabilityInstanceAlertConfigResult': + """ + Alert configuration for the instance. + """ + return pulumi.get(self, "alert_config") + + @property + @pulumi.getter(name="alertingUrl") + def alerting_url(self) -> builtins.str: + """ + Specifies Alerting URL. + """ + return pulumi.get(self, "alerting_url") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + """ + Specifies Observability instance dashboard URL. + """ + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="grafanaInitialAdminPassword") + def grafana_initial_admin_password(self) -> builtins.str: + """ + Specifies an initial Grafana admin password. + """ + return pulumi.get(self, "grafana_initial_admin_password") + + @property + @pulumi.getter(name="grafanaInitialAdminUser") + def grafana_initial_admin_user(self) -> builtins.str: + """ + Specifies an initial Grafana admin username. + """ + return pulumi.get(self, "grafana_initial_admin_user") + + @property + @pulumi.getter(name="grafanaPublicReadAccess") + def grafana_public_read_access(self) -> builtins.bool: + """ + If true, anyone can access Grafana dashboards without logging in. + """ + return pulumi.get(self, "grafana_public_read_access") + + @property + @pulumi.getter(name="grafanaUrl") + def grafana_url(self) -> builtins.str: + """ + Specifies Grafana URL. + """ + return pulumi.get(self, "grafana_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + The Observability instance ID. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="isUpdatable") + def is_updatable(self) -> builtins.bool: + """ + Specifies if the instance can be updated. + """ + return pulumi.get(self, "is_updatable") + + @property + @pulumi.getter(name="jaegerTracesUrl") + def jaeger_traces_url(self) -> builtins.str: + return pulumi.get(self, "jaeger_traces_url") + + @property + @pulumi.getter(name="jaegerUiUrl") + def jaeger_ui_url(self) -> builtins.str: + return pulumi.get(self, "jaeger_ui_url") + + @property + @pulumi.getter(name="logsPushUrl") + def logs_push_url(self) -> builtins.str: + """ + Specifies URL for pushing logs. + """ + return pulumi.get(self, "logs_push_url") + + @property + @pulumi.getter(name="logsUrl") + def logs_url(self) -> builtins.str: + """ + Specifies Logs URL. + """ + return pulumi.get(self, "logs_url") + + @property + @pulumi.getter(name="metricsPushUrl") + def metrics_push_url(self) -> builtins.str: + """ + Specifies URL for pushing metrics. + """ + return pulumi.get(self, "metrics_push_url") + + @property + @pulumi.getter(name="metricsRetentionDays") + def metrics_retention_days(self) -> builtins.int: + """ + Specifies for how many days the raw metrics are kept. + """ + return pulumi.get(self, "metrics_retention_days") + + @property + @pulumi.getter(name="metricsRetentionDays1hDownsampling") + def metrics_retention_days1h_downsampling(self) -> builtins.int: + """ + Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days1h_downsampling") + + @property + @pulumi.getter(name="metricsRetentionDays5mDownsampling") + def metrics_retention_days5m_downsampling(self) -> builtins.int: + """ + Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days5m_downsampling") + + @property + @pulumi.getter(name="metricsUrl") + def metrics_url(self) -> builtins.str: + """ + Specifies metrics URL. + """ + return pulumi.get(self, "metrics_url") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the Observability instance. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="otlpTracesUrl") + def otlp_traces_url(self) -> builtins.str: + return pulumi.get(self, "otlp_traces_url") + + @property + @pulumi.getter + def parameters(self) -> Mapping[str, builtins.str]: + """ + Additional parameters. + """ + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The Observability plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="targetsUrl") + def targets_url(self) -> builtins.str: + """ + Specifies Targets URL. + """ + return pulumi.get(self, "targets_url") + + @property + @pulumi.getter(name="zipkinSpansUrl") + def zipkin_spans_url(self) -> builtins.str: + return pulumi.get(self, "zipkin_spans_url") + + +class AwaitableGetObservabilityInstanceResult(GetObservabilityInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObservabilityInstanceResult( + acls=self.acls, + alert_config=self.alert_config, + alerting_url=self.alerting_url, + dashboard_url=self.dashboard_url, + grafana_initial_admin_password=self.grafana_initial_admin_password, + grafana_initial_admin_user=self.grafana_initial_admin_user, + grafana_public_read_access=self.grafana_public_read_access, + grafana_url=self.grafana_url, + id=self.id, + instance_id=self.instance_id, + is_updatable=self.is_updatable, + jaeger_traces_url=self.jaeger_traces_url, + jaeger_ui_url=self.jaeger_ui_url, + logs_push_url=self.logs_push_url, + logs_url=self.logs_url, + metrics_push_url=self.metrics_push_url, + metrics_retention_days=self.metrics_retention_days, + metrics_retention_days1h_downsampling=self.metrics_retention_days1h_downsampling, + metrics_retention_days5m_downsampling=self.metrics_retention_days5m_downsampling, + metrics_url=self.metrics_url, + name=self.name, + otlp_traces_url=self.otlp_traces_url, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + targets_url=self.targets_url, + zipkin_spans_url=self.zipkin_spans_url) + + +def get_observability_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObservabilityInstanceResult: + """ + Observability instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: The Observability instance ID. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObservabilityInstance:getObservabilityInstance', __args__, opts=opts, typ=GetObservabilityInstanceResult).value + + return AwaitableGetObservabilityInstanceResult( + acls=pulumi.get(__ret__, 'acls'), + alert_config=pulumi.get(__ret__, 'alert_config'), + alerting_url=pulumi.get(__ret__, 'alerting_url'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + grafana_initial_admin_password=pulumi.get(__ret__, 'grafana_initial_admin_password'), + grafana_initial_admin_user=pulumi.get(__ret__, 'grafana_initial_admin_user'), + grafana_public_read_access=pulumi.get(__ret__, 'grafana_public_read_access'), + grafana_url=pulumi.get(__ret__, 'grafana_url'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + is_updatable=pulumi.get(__ret__, 'is_updatable'), + jaeger_traces_url=pulumi.get(__ret__, 'jaeger_traces_url'), + jaeger_ui_url=pulumi.get(__ret__, 'jaeger_ui_url'), + logs_push_url=pulumi.get(__ret__, 'logs_push_url'), + logs_url=pulumi.get(__ret__, 'logs_url'), + metrics_push_url=pulumi.get(__ret__, 'metrics_push_url'), + metrics_retention_days=pulumi.get(__ret__, 'metrics_retention_days'), + metrics_retention_days1h_downsampling=pulumi.get(__ret__, 'metrics_retention_days1h_downsampling'), + metrics_retention_days5m_downsampling=pulumi.get(__ret__, 'metrics_retention_days5m_downsampling'), + metrics_url=pulumi.get(__ret__, 'metrics_url'), + name=pulumi.get(__ret__, 'name'), + otlp_traces_url=pulumi.get(__ret__, 'otlp_traces_url'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + targets_url=pulumi.get(__ret__, 'targets_url'), + zipkin_spans_url=pulumi.get(__ret__, 'zipkin_spans_url')) +def get_observability_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObservabilityInstanceResult]: + """ + Observability instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: The Observability instance ID. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObservabilityInstance:getObservabilityInstance', __args__, opts=opts, typ=GetObservabilityInstanceResult) + return __ret__.apply(lambda __response__: GetObservabilityInstanceResult( + acls=pulumi.get(__response__, 'acls'), + alert_config=pulumi.get(__response__, 'alert_config'), + alerting_url=pulumi.get(__response__, 'alerting_url'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + grafana_initial_admin_password=pulumi.get(__response__, 'grafana_initial_admin_password'), + grafana_initial_admin_user=pulumi.get(__response__, 'grafana_initial_admin_user'), + grafana_public_read_access=pulumi.get(__response__, 'grafana_public_read_access'), + grafana_url=pulumi.get(__response__, 'grafana_url'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + is_updatable=pulumi.get(__response__, 'is_updatable'), + jaeger_traces_url=pulumi.get(__response__, 'jaeger_traces_url'), + jaeger_ui_url=pulumi.get(__response__, 'jaeger_ui_url'), + logs_push_url=pulumi.get(__response__, 'logs_push_url'), + logs_url=pulumi.get(__response__, 'logs_url'), + metrics_push_url=pulumi.get(__response__, 'metrics_push_url'), + metrics_retention_days=pulumi.get(__response__, 'metrics_retention_days'), + metrics_retention_days1h_downsampling=pulumi.get(__response__, 'metrics_retention_days1h_downsampling'), + metrics_retention_days5m_downsampling=pulumi.get(__response__, 'metrics_retention_days5m_downsampling'), + metrics_url=pulumi.get(__response__, 'metrics_url'), + name=pulumi.get(__response__, 'name'), + otlp_traces_url=pulumi.get(__response__, 'otlp_traces_url'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + targets_url=pulumi.get(__response__, 'targets_url'), + zipkin_spans_url=pulumi.get(__response__, 'zipkin_spans_url'))) diff --git a/sdk/python/pulumi_stackit/get_observability_logalertgroup.py b/sdk/python/pulumi_stackit/get_observability_logalertgroup.py new file mode 100644 index 0000000..cbffe73 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_observability_logalertgroup.py @@ -0,0 +1,162 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetObservabilityLogalertgroupResult', + 'AwaitableGetObservabilityLogalertgroupResult', + 'get_observability_logalertgroup', + 'get_observability_logalertgroup_output', +] + +@pulumi.output_type +class GetObservabilityLogalertgroupResult: + """ + A collection of values returned by getObservabilityLogalertgroup. + """ + def __init__(__self__, id=None, instance_id=None, interval=None, name=None, project_id=None, rules=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if interval and not isinstance(interval, str): + raise TypeError("Expected argument 'interval' to be a str") + pulumi.set(__self__, "interval", interval) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if rules and not isinstance(rules, list): + raise TypeError("Expected argument 'rules' to be a list") + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + Observability instance ID to which the log alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def interval(self) -> builtins.str: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the log alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the log alert group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def rules(self) -> Sequence['outputs.GetObservabilityLogalertgroupRuleResult']: + return pulumi.get(self, "rules") + + +class AwaitableGetObservabilityLogalertgroupResult(GetObservabilityLogalertgroupResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObservabilityLogalertgroupResult( + id=self.id, + instance_id=self.instance_id, + interval=self.interval, + name=self.name, + project_id=self.project_id, + rules=self.rules) + + +def get_observability_logalertgroup(instance_id: Optional[builtins.str] = None, + name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObservabilityLogalertgroupResult: + """ + Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the log alert group is associated. + :param builtins.str name: The name of the log alert group. Is the identifier and must be unique in the group. + :param builtins.str project_id: STACKIT project ID to which the log alert group is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup', __args__, opts=opts, typ=GetObservabilityLogalertgroupResult).value + + return AwaitableGetObservabilityLogalertgroupResult( + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + interval=pulumi.get(__ret__, 'interval'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + rules=pulumi.get(__ret__, 'rules')) +def get_observability_logalertgroup_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObservabilityLogalertgroupResult]: + """ + Observability log alert group datasource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the log alert group is associated. + :param builtins.str name: The name of the log alert group. Is the identifier and must be unique in the group. + :param builtins.str project_id: STACKIT project ID to which the log alert group is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObservabilityLogalertgroup:getObservabilityLogalertgroup', __args__, opts=opts, typ=GetObservabilityLogalertgroupResult) + return __ret__.apply(lambda __response__: GetObservabilityLogalertgroupResult( + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + interval=pulumi.get(__response__, 'interval'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + rules=pulumi.get(__response__, 'rules'))) diff --git a/sdk/python/pulumi_stackit/get_observability_scrapeconfig.py b/sdk/python/pulumi_stackit/get_observability_scrapeconfig.py new file mode 100644 index 0000000..cb6a8c2 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_observability_scrapeconfig.py @@ -0,0 +1,249 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetObservabilityScrapeconfigResult', + 'AwaitableGetObservabilityScrapeconfigResult', + 'get_observability_scrapeconfig', + 'get_observability_scrapeconfig_output', +] + +@pulumi.output_type +class GetObservabilityScrapeconfigResult: + """ + A collection of values returned by getObservabilityScrapeconfig. + """ + def __init__(__self__, basic_auth=None, id=None, instance_id=None, metrics_path=None, name=None, project_id=None, saml2=None, sample_limit=None, scheme=None, scrape_interval=None, scrape_timeout=None, targets=None): + if basic_auth and not isinstance(basic_auth, dict): + raise TypeError("Expected argument 'basic_auth' to be a dict") + pulumi.set(__self__, "basic_auth", basic_auth) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if metrics_path and not isinstance(metrics_path, str): + raise TypeError("Expected argument 'metrics_path' to be a str") + pulumi.set(__self__, "metrics_path", metrics_path) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if saml2 and not isinstance(saml2, dict): + raise TypeError("Expected argument 'saml2' to be a dict") + pulumi.set(__self__, "saml2", saml2) + if sample_limit and not isinstance(sample_limit, int): + raise TypeError("Expected argument 'sample_limit' to be a int") + pulumi.set(__self__, "sample_limit", sample_limit) + if scheme and not isinstance(scheme, str): + raise TypeError("Expected argument 'scheme' to be a str") + pulumi.set(__self__, "scheme", scheme) + if scrape_interval and not isinstance(scrape_interval, str): + raise TypeError("Expected argument 'scrape_interval' to be a str") + pulumi.set(__self__, "scrape_interval", scrape_interval) + if scrape_timeout and not isinstance(scrape_timeout, str): + raise TypeError("Expected argument 'scrape_timeout' to be a str") + pulumi.set(__self__, "scrape_timeout", scrape_timeout) + if targets and not isinstance(targets, list): + raise TypeError("Expected argument 'targets' to be a list") + pulumi.set(__self__, "targets", targets) + + @property + @pulumi.getter(name="basicAuth") + def basic_auth(self) -> 'outputs.GetObservabilityScrapeconfigBasicAuthResult': + """ + A basic authentication block. + """ + return pulumi.get(self, "basic_auth") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + Observability instance ID to which the scraping job is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="metricsPath") + def metrics_path(self) -> builtins.str: + """ + Specifies the job scraping url path. + """ + return pulumi.get(self, "metrics_path") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Specifies the name of the scraping job + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the scraping job is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def saml2(self) -> 'outputs.GetObservabilityScrapeconfigSaml2Result': + """ + A SAML2 configuration block. + """ + return pulumi.get(self, "saml2") + + @property + @pulumi.getter(name="sampleLimit") + def sample_limit(self) -> builtins.int: + """ + Specifies the scrape sample limit. + """ + return pulumi.get(self, "sample_limit") + + @property + @pulumi.getter + def scheme(self) -> builtins.str: + """ + Specifies the http scheme. + """ + return pulumi.get(self, "scheme") + + @property + @pulumi.getter(name="scrapeInterval") + def scrape_interval(self) -> builtins.str: + """ + Specifies the scrape interval as duration string. + """ + return pulumi.get(self, "scrape_interval") + + @property + @pulumi.getter(name="scrapeTimeout") + def scrape_timeout(self) -> builtins.str: + """ + Specifies the scrape timeout as duration string. + """ + return pulumi.get(self, "scrape_timeout") + + @property + @pulumi.getter + def targets(self) -> Sequence['outputs.GetObservabilityScrapeconfigTargetResult']: + """ + The targets list (specified by the static config). + """ + return pulumi.get(self, "targets") + + +class AwaitableGetObservabilityScrapeconfigResult(GetObservabilityScrapeconfigResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetObservabilityScrapeconfigResult( + basic_auth=self.basic_auth, + id=self.id, + instance_id=self.instance_id, + metrics_path=self.metrics_path, + name=self.name, + project_id=self.project_id, + saml2=self.saml2, + sample_limit=self.sample_limit, + scheme=self.scheme, + scrape_interval=self.scrape_interval, + scrape_timeout=self.scrape_timeout, + targets=self.targets) + + +def get_observability_scrapeconfig(instance_id: Optional[builtins.str] = None, + name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetObservabilityScrapeconfigResult: + """ + Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the scraping job is associated. + :param builtins.str name: Specifies the name of the scraping job + :param builtins.str project_id: STACKIT project ID to which the scraping job is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig', __args__, opts=opts, typ=GetObservabilityScrapeconfigResult).value + + return AwaitableGetObservabilityScrapeconfigResult( + basic_auth=pulumi.get(__ret__, 'basic_auth'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + metrics_path=pulumi.get(__ret__, 'metrics_path'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + saml2=pulumi.get(__ret__, 'saml2'), + sample_limit=pulumi.get(__ret__, 'sample_limit'), + scheme=pulumi.get(__ret__, 'scheme'), + scrape_interval=pulumi.get(__ret__, 'scrape_interval'), + scrape_timeout=pulumi.get(__ret__, 'scrape_timeout'), + targets=pulumi.get(__ret__, 'targets')) +def get_observability_scrapeconfig_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetObservabilityScrapeconfigResult]: + """ + Observability scrape config data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: Observability instance ID to which the scraping job is associated. + :param builtins.str name: Specifies the name of the scraping job + :param builtins.str project_id: STACKIT project ID to which the scraping job is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['name'] = name + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getObservabilityScrapeconfig:getObservabilityScrapeconfig', __args__, opts=opts, typ=GetObservabilityScrapeconfigResult) + return __ret__.apply(lambda __response__: GetObservabilityScrapeconfigResult( + basic_auth=pulumi.get(__response__, 'basic_auth'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + metrics_path=pulumi.get(__response__, 'metrics_path'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + saml2=pulumi.get(__response__, 'saml2'), + sample_limit=pulumi.get(__response__, 'sample_limit'), + scheme=pulumi.get(__response__, 'scheme'), + scrape_interval=pulumi.get(__response__, 'scrape_interval'), + scrape_timeout=pulumi.get(__response__, 'scrape_timeout'), + targets=pulumi.get(__response__, 'targets'))) diff --git a/sdk/python/pulumi_stackit/get_opensearch_credential.py b/sdk/python/pulumi_stackit/get_opensearch_credential.py new file mode 100644 index 0000000..07b9eb6 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_opensearch_credential.py @@ -0,0 +1,213 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetOpensearchCredentialResult', + 'AwaitableGetOpensearchCredentialResult', + 'get_opensearch_credential', + 'get_opensearch_credential_output', +] + +@pulumi.output_type +class GetOpensearchCredentialResult: + """ + A collection of values returned by getOpensearchCredential. + """ + def __init__(__self__, credential_id=None, host=None, hosts=None, id=None, instance_id=None, password=None, port=None, project_id=None, scheme=None, uri=None, username=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if hosts and not isinstance(hosts, list): + raise TypeError("Expected argument 'hosts' to be a list") + pulumi.set(__self__, "hosts", hosts) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if password and not isinstance(password, str): + raise TypeError("Expected argument 'password' to be a str") + pulumi.set(__self__, "password", password) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if scheme and not isinstance(scheme, str): + raise TypeError("Expected argument 'scheme' to be a str") + pulumi.set(__self__, "scheme", scheme) + if uri and not isinstance(uri, str): + raise TypeError("Expected argument 'uri' to be a str") + pulumi.set(__self__, "uri", uri) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> Sequence[builtins.str]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> builtins.str: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def scheme(self) -> builtins.str: + return pulumi.get(self, "scheme") + + @property + @pulumi.getter + def uri(self) -> builtins.str: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetOpensearchCredentialResult(GetOpensearchCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetOpensearchCredentialResult( + credential_id=self.credential_id, + host=self.host, + hosts=self.hosts, + id=self.id, + instance_id=self.instance_id, + password=self.password, + port=self.port, + project_id=self.project_id, + scheme=self.scheme, + uri=self.uri, + username=self.username) + + +def get_opensearch_credential(credential_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetOpensearchCredentialResult: + """ + OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the OpenSearch instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getOpensearchCredential:getOpensearchCredential', __args__, opts=opts, typ=GetOpensearchCredentialResult).value + + return AwaitableGetOpensearchCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + host=pulumi.get(__ret__, 'host'), + hosts=pulumi.get(__ret__, 'hosts'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + password=pulumi.get(__ret__, 'password'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + scheme=pulumi.get(__ret__, 'scheme'), + uri=pulumi.get(__ret__, 'uri'), + username=pulumi.get(__ret__, 'username')) +def get_opensearch_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetOpensearchCredentialResult]: + """ + OpenSearch credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the OpenSearch instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getOpensearchCredential:getOpensearchCredential', __args__, opts=opts, typ=GetOpensearchCredentialResult) + return __ret__.apply(lambda __response__: GetOpensearchCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + host=pulumi.get(__response__, 'host'), + hosts=pulumi.get(__response__, 'hosts'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + password=pulumi.get(__response__, 'password'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + scheme=pulumi.get(__response__, 'scheme'), + uri=pulumi.get(__response__, 'uri'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_opensearch_instance.py b/sdk/python/pulumi_stackit/get_opensearch_instance.py new file mode 100644 index 0000000..e63f7ee --- /dev/null +++ b/sdk/python/pulumi_stackit/get_opensearch_instance.py @@ -0,0 +1,239 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetOpensearchInstanceResult', + 'AwaitableGetOpensearchInstanceResult', + 'get_opensearch_instance', + 'get_opensearch_instance_output', +] + +@pulumi.output_type +class GetOpensearchInstanceResult: + """ + A collection of values returned by getOpensearchInstance. + """ + def __init__(__self__, cf_guid=None, cf_organization_guid=None, cf_space_guid=None, dashboard_url=None, id=None, image_url=None, instance_id=None, name=None, parameters=None, plan_id=None, plan_name=None, project_id=None, version=None): + if cf_guid and not isinstance(cf_guid, str): + raise TypeError("Expected argument 'cf_guid' to be a str") + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid and not isinstance(cf_organization_guid, str): + raise TypeError("Expected argument 'cf_organization_guid' to be a str") + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid and not isinstance(cf_space_guid, str): + raise TypeError("Expected argument 'cf_space_guid' to be a str") + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_url and not isinstance(image_url, str): + raise TypeError("Expected argument 'image_url' to be a str") + pulumi.set(__self__, "image_url", image_url) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> builtins.str: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> builtins.str: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> builtins.str: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> builtins.str: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> 'outputs.GetOpensearchInstanceParametersResult': + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + The service version. + """ + return pulumi.get(self, "version") + + +class AwaitableGetOpensearchInstanceResult(GetOpensearchInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetOpensearchInstanceResult( + cf_guid=self.cf_guid, + cf_organization_guid=self.cf_organization_guid, + cf_space_guid=self.cf_space_guid, + dashboard_url=self.dashboard_url, + id=self.id, + image_url=self.image_url, + instance_id=self.instance_id, + name=self.name, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + version=self.version) + + +def get_opensearch_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetOpensearchInstanceResult: + """ + OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the OpenSearch instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getOpensearchInstance:getOpensearchInstance', __args__, opts=opts, typ=GetOpensearchInstanceResult).value + + return AwaitableGetOpensearchInstanceResult( + cf_guid=pulumi.get(__ret__, 'cf_guid'), + cf_organization_guid=pulumi.get(__ret__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__ret__, 'cf_space_guid'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + id=pulumi.get(__ret__, 'id'), + image_url=pulumi.get(__ret__, 'image_url'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + version=pulumi.get(__ret__, 'version')) +def get_opensearch_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetOpensearchInstanceResult]: + """ + OpenSearch instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the OpenSearch instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getOpensearchInstance:getOpensearchInstance', __args__, opts=opts, typ=GetOpensearchInstanceResult) + return __ret__.apply(lambda __response__: GetOpensearchInstanceResult( + cf_guid=pulumi.get(__response__, 'cf_guid'), + cf_organization_guid=pulumi.get(__response__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__response__, 'cf_space_guid'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + id=pulumi.get(__response__, 'id'), + image_url=pulumi.get(__response__, 'image_url'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_postgresflex_database.py b/sdk/python/pulumi_stackit/get_postgresflex_database.py new file mode 100644 index 0000000..b98fb27 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_postgresflex_database.py @@ -0,0 +1,184 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetPostgresflexDatabaseResult', + 'AwaitableGetPostgresflexDatabaseResult', + 'get_postgresflex_database', + 'get_postgresflex_database_output', +] + +@pulumi.output_type +class GetPostgresflexDatabaseResult: + """ + A collection of values returned by getPostgresflexDatabase. + """ + def __init__(__self__, database_id=None, id=None, instance_id=None, name=None, owner=None, project_id=None, region=None): + if database_id and not isinstance(database_id, str): + raise TypeError("Expected argument 'database_id' to be a str") + pulumi.set(__self__, "database_id", database_id) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if owner and not isinstance(owner, str): + raise TypeError("Expected argument 'owner' to be a str") + pulumi.set(__self__, "owner", owner) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="databaseId") + def database_id(self) -> builtins.str: + """ + Database ID. + """ + return pulumi.get(self, "database_id") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the Postgres Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Database name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def owner(self) -> builtins.str: + """ + Username of the database owner. + """ + return pulumi.get(self, "owner") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + +class AwaitableGetPostgresflexDatabaseResult(GetPostgresflexDatabaseResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPostgresflexDatabaseResult( + database_id=self.database_id, + id=self.id, + instance_id=self.instance_id, + name=self.name, + owner=self.owner, + project_id=self.project_id, + region=self.region) + + +def get_postgresflex_database(database_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPostgresflexDatabaseResult: + """ + Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str database_id: Database ID. + :param builtins.str instance_id: ID of the Postgres Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['databaseId'] = database_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getPostgresflexDatabase:getPostgresflexDatabase', __args__, opts=opts, typ=GetPostgresflexDatabaseResult).value + + return AwaitableGetPostgresflexDatabaseResult( + database_id=pulumi.get(__ret__, 'database_id'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + owner=pulumi.get(__ret__, 'owner'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region')) +def get_postgresflex_database_output(database_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPostgresflexDatabaseResult]: + """ + Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str database_id: Database ID. + :param builtins.str instance_id: ID of the Postgres Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['databaseId'] = database_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getPostgresflexDatabase:getPostgresflexDatabase', __args__, opts=opts, typ=GetPostgresflexDatabaseResult) + return __ret__.apply(lambda __response__: GetPostgresflexDatabaseResult( + database_id=pulumi.get(__response__, 'database_id'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + owner=pulumi.get(__response__, 'owner'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'))) diff --git a/sdk/python/pulumi_stackit/get_postgresflex_instance.py b/sdk/python/pulumi_stackit/get_postgresflex_instance.py new file mode 100644 index 0000000..614ebdc --- /dev/null +++ b/sdk/python/pulumi_stackit/get_postgresflex_instance.py @@ -0,0 +1,220 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetPostgresflexInstanceResult', + 'AwaitableGetPostgresflexInstanceResult', + 'get_postgresflex_instance', + 'get_postgresflex_instance_output', +] + +@pulumi.output_type +class GetPostgresflexInstanceResult: + """ + A collection of values returned by getPostgresflexInstance. + """ + def __init__(__self__, acls=None, backup_schedule=None, flavor=None, id=None, instance_id=None, name=None, project_id=None, region=None, replicas=None, storage=None, version=None): + if acls and not isinstance(acls, list): + raise TypeError("Expected argument 'acls' to be a list") + pulumi.set(__self__, "acls", acls) + if backup_schedule and not isinstance(backup_schedule, str): + raise TypeError("Expected argument 'backup_schedule' to be a str") + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor and not isinstance(flavor, dict): + raise TypeError("Expected argument 'flavor' to be a dict") + pulumi.set(__self__, "flavor", flavor) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if replicas and not isinstance(replicas, int): + raise TypeError("Expected argument 'replicas' to be a int") + pulumi.set(__self__, "replicas", replicas) + if storage and not isinstance(storage, dict): + raise TypeError("Expected argument 'storage' to be a dict") + pulumi.set(__self__, "storage", storage) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + The Access Control List (ACL) for the PostgresFlex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> builtins.str: + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> 'outputs.GetPostgresflexInstanceFlavorResult': + return pulumi.get(self, "flavor") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def replicas(self) -> builtins.int: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> 'outputs.GetPostgresflexInstanceStorageResult': + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> builtins.str: + return pulumi.get(self, "version") + + +class AwaitableGetPostgresflexInstanceResult(GetPostgresflexInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPostgresflexInstanceResult( + acls=self.acls, + backup_schedule=self.backup_schedule, + flavor=self.flavor, + id=self.id, + instance_id=self.instance_id, + name=self.name, + project_id=self.project_id, + region=self.region, + replicas=self.replicas, + storage=self.storage, + version=self.version) + + +def get_postgresflex_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPostgresflexInstanceResult: + """ + Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the PostgresFlex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getPostgresflexInstance:getPostgresflexInstance', __args__, opts=opts, typ=GetPostgresflexInstanceResult).value + + return AwaitableGetPostgresflexInstanceResult( + acls=pulumi.get(__ret__, 'acls'), + backup_schedule=pulumi.get(__ret__, 'backup_schedule'), + flavor=pulumi.get(__ret__, 'flavor'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + replicas=pulumi.get(__ret__, 'replicas'), + storage=pulumi.get(__ret__, 'storage'), + version=pulumi.get(__ret__, 'version')) +def get_postgresflex_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPostgresflexInstanceResult]: + """ + Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the PostgresFlex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getPostgresflexInstance:getPostgresflexInstance', __args__, opts=opts, typ=GetPostgresflexInstanceResult) + return __ret__.apply(lambda __response__: GetPostgresflexInstanceResult( + acls=pulumi.get(__response__, 'acls'), + backup_schedule=pulumi.get(__response__, 'backup_schedule'), + flavor=pulumi.get(__response__, 'flavor'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + replicas=pulumi.get(__response__, 'replicas'), + storage=pulumi.get(__response__, 'storage'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_postgresflex_user.py b/sdk/python/pulumi_stackit/get_postgresflex_user.py new file mode 100644 index 0000000..9d6a8c8 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_postgresflex_user.py @@ -0,0 +1,200 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetPostgresflexUserResult', + 'AwaitableGetPostgresflexUserResult', + 'get_postgresflex_user', + 'get_postgresflex_user_output', +] + +@pulumi.output_type +class GetPostgresflexUserResult: + """ + A collection of values returned by getPostgresflexUser. + """ + def __init__(__self__, host=None, id=None, instance_id=None, port=None, project_id=None, region=None, roles=None, user_id=None, username=None): + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if roles and not isinstance(roles, list): + raise TypeError("Expected argument 'roles' to be a list") + pulumi.set(__self__, "roles", roles) + if user_id and not isinstance(user_id, str): + raise TypeError("Expected argument 'user_id' to be a str") + pulumi.set(__self__, "user_id", user_id) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def roles(self) -> Sequence[builtins.str]: + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> builtins.str: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetPostgresflexUserResult(GetPostgresflexUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPostgresflexUserResult( + host=self.host, + id=self.id, + instance_id=self.instance_id, + port=self.port, + project_id=self.project_id, + region=self.region, + roles=self.roles, + user_id=self.user_id, + username=self.username) + + +def get_postgresflex_user(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + user_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPostgresflexUserResult: + """ + Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the PostgresFlex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getPostgresflexUser:getPostgresflexUser', __args__, opts=opts, typ=GetPostgresflexUserResult).value + + return AwaitableGetPostgresflexUserResult( + host=pulumi.get(__ret__, 'host'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + roles=pulumi.get(__ret__, 'roles'), + user_id=pulumi.get(__ret__, 'user_id'), + username=pulumi.get(__ret__, 'username')) +def get_postgresflex_user_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPostgresflexUserResult]: + """ + Postgres Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the PostgresFlex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getPostgresflexUser:getPostgresflexUser', __args__, opts=opts, typ=GetPostgresflexUserResult) + return __ret__.apply(lambda __response__: GetPostgresflexUserResult( + host=pulumi.get(__response__, 'host'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + roles=pulumi.get(__response__, 'roles'), + user_id=pulumi.get(__response__, 'user_id'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_public_ip.py b/sdk/python/pulumi_stackit/get_public_ip.py new file mode 100644 index 0000000..0c5f603 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_public_ip.py @@ -0,0 +1,158 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetPublicIpResult', + 'AwaitableGetPublicIpResult', + 'get_public_ip', + 'get_public_ip_output', +] + +@pulumi.output_type +class GetPublicIpResult: + """ + A collection of values returned by getPublicIp. + """ + def __init__(__self__, id=None, ip=None, labels=None, network_interface_id=None, project_id=None, public_ip_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if ip and not isinstance(ip, str): + raise TypeError("Expected argument 'ip' to be a str") + pulumi.set(__self__, "ip", ip) + if labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if network_interface_id and not isinstance(network_interface_id, str): + raise TypeError("Expected argument 'network_interface_id' to be a str") + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if public_ip_id and not isinstance(public_ip_id, str): + raise TypeError("Expected argument 'public_ip_id' to be a str") + pulumi.set(__self__, "public_ip_id", public_ip_id) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def ip(self) -> builtins.str: + """ + The IP address. + """ + return pulumi.get(self, "ip") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> builtins.str: + """ + Associates the public IP with a network interface or a virtual IP (ID). + """ + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> builtins.str: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + + +class AwaitableGetPublicIpResult(GetPublicIpResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPublicIpResult( + id=self.id, + ip=self.ip, + labels=self.labels, + network_interface_id=self.network_interface_id, + project_id=self.project_id, + public_ip_id=self.public_ip_id) + + +def get_public_ip(project_id: Optional[builtins.str] = None, + public_ip_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPublicIpResult: + """ + Public IP resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the public IP is associated. + :param builtins.str public_ip_id: The public IP ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['publicIpId'] = public_ip_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getPublicIp:getPublicIp', __args__, opts=opts, typ=GetPublicIpResult).value + + return AwaitableGetPublicIpResult( + id=pulumi.get(__ret__, 'id'), + ip=pulumi.get(__ret__, 'ip'), + labels=pulumi.get(__ret__, 'labels'), + network_interface_id=pulumi.get(__ret__, 'network_interface_id'), + project_id=pulumi.get(__ret__, 'project_id'), + public_ip_id=pulumi.get(__ret__, 'public_ip_id')) +def get_public_ip_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPublicIpResult]: + """ + Public IP resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the public IP is associated. + :param builtins.str public_ip_id: The public IP ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['publicIpId'] = public_ip_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getPublicIp:getPublicIp', __args__, opts=opts, typ=GetPublicIpResult) + return __ret__.apply(lambda __response__: GetPublicIpResult( + id=pulumi.get(__response__, 'id'), + ip=pulumi.get(__response__, 'ip'), + labels=pulumi.get(__response__, 'labels'), + network_interface_id=pulumi.get(__response__, 'network_interface_id'), + project_id=pulumi.get(__response__, 'project_id'), + public_ip_id=pulumi.get(__response__, 'public_ip_id'))) diff --git a/sdk/python/pulumi_stackit/get_public_ip_ranges.py b/sdk/python/pulumi_stackit/get_public_ip_ranges.py new file mode 100644 index 0000000..566cd98 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_public_ip_ranges.py @@ -0,0 +1,87 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetPublicIpRangesResult', + 'AwaitableGetPublicIpRangesResult', + 'get_public_ip_ranges', + 'get_public_ip_ranges_output', +] + +@pulumi.output_type +class GetPublicIpRangesResult: + """ + A collection of values returned by getPublicIpRanges. + """ + def __init__(__self__, id=None, public_ip_ranges=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if public_ip_ranges and not isinstance(public_ip_ranges, list): + raise TypeError("Expected argument 'public_ip_ranges' to be a list") + pulumi.set(__self__, "public_ip_ranges", public_ip_ranges) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="publicIpRanges") + def public_ip_ranges(self) -> Sequence['outputs.GetPublicIpRangesPublicIpRangeResult']: + """ + A list of all public IP ranges. + """ + return pulumi.get(self, "public_ip_ranges") + + +class AwaitableGetPublicIpRangesResult(GetPublicIpRangesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetPublicIpRangesResult( + id=self.id, + public_ip_ranges=self.public_ip_ranges) + + +def get_public_ip_ranges(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPublicIpRangesResult: + """ + A list of all public IP ranges that STACKIT uses. + + ## Example Usage + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getPublicIpRanges:getPublicIpRanges', __args__, opts=opts, typ=GetPublicIpRangesResult).value + + return AwaitableGetPublicIpRangesResult( + id=pulumi.get(__ret__, 'id'), + public_ip_ranges=pulumi.get(__ret__, 'public_ip_ranges')) +def get_public_ip_ranges_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPublicIpRangesResult]: + """ + A list of all public IP ranges that STACKIT uses. + + ## Example Usage + """ + __args__ = dict() + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getPublicIpRanges:getPublicIpRanges', __args__, opts=opts, typ=GetPublicIpRangesResult) + return __ret__.apply(lambda __response__: GetPublicIpRangesResult( + id=pulumi.get(__response__, 'id'), + public_ip_ranges=pulumi.get(__response__, 'public_ip_ranges'))) diff --git a/sdk/python/pulumi_stackit/get_rabbitmq_credential.py b/sdk/python/pulumi_stackit/get_rabbitmq_credential.py new file mode 100644 index 0000000..445d978 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_rabbitmq_credential.py @@ -0,0 +1,246 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetRabbitmqCredentialResult', + 'AwaitableGetRabbitmqCredentialResult', + 'get_rabbitmq_credential', + 'get_rabbitmq_credential_output', +] + +@pulumi.output_type +class GetRabbitmqCredentialResult: + """ + A collection of values returned by getRabbitmqCredential. + """ + def __init__(__self__, credential_id=None, host=None, hosts=None, http_api_uri=None, http_api_uris=None, id=None, instance_id=None, management=None, password=None, port=None, project_id=None, uri=None, uris=None, username=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if hosts and not isinstance(hosts, list): + raise TypeError("Expected argument 'hosts' to be a list") + pulumi.set(__self__, "hosts", hosts) + if http_api_uri and not isinstance(http_api_uri, str): + raise TypeError("Expected argument 'http_api_uri' to be a str") + pulumi.set(__self__, "http_api_uri", http_api_uri) + if http_api_uris and not isinstance(http_api_uris, list): + raise TypeError("Expected argument 'http_api_uris' to be a list") + pulumi.set(__self__, "http_api_uris", http_api_uris) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if management and not isinstance(management, str): + raise TypeError("Expected argument 'management' to be a str") + pulumi.set(__self__, "management", management) + if password and not isinstance(password, str): + raise TypeError("Expected argument 'password' to be a str") + pulumi.set(__self__, "password", password) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if uri and not isinstance(uri, str): + raise TypeError("Expected argument 'uri' to be a str") + pulumi.set(__self__, "uri", uri) + if uris and not isinstance(uris, list): + raise TypeError("Expected argument 'uris' to be a list") + pulumi.set(__self__, "uris", uris) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> Sequence[builtins.str]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter(name="httpApiUri") + def http_api_uri(self) -> builtins.str: + return pulumi.get(self, "http_api_uri") + + @property + @pulumi.getter(name="httpApiUris") + def http_api_uris(self) -> Sequence[builtins.str]: + return pulumi.get(self, "http_api_uris") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def management(self) -> builtins.str: + return pulumi.get(self, "management") + + @property + @pulumi.getter + def password(self) -> builtins.str: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> builtins.str: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def uris(self) -> Sequence[builtins.str]: + return pulumi.get(self, "uris") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetRabbitmqCredentialResult(GetRabbitmqCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetRabbitmqCredentialResult( + credential_id=self.credential_id, + host=self.host, + hosts=self.hosts, + http_api_uri=self.http_api_uri, + http_api_uris=self.http_api_uris, + id=self.id, + instance_id=self.instance_id, + management=self.management, + password=self.password, + port=self.port, + project_id=self.project_id, + uri=self.uri, + uris=self.uris, + username=self.username) + + +def get_rabbitmq_credential(credential_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRabbitmqCredentialResult: + """ + RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the RabbitMQ instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getRabbitmqCredential:getRabbitmqCredential', __args__, opts=opts, typ=GetRabbitmqCredentialResult).value + + return AwaitableGetRabbitmqCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + host=pulumi.get(__ret__, 'host'), + hosts=pulumi.get(__ret__, 'hosts'), + http_api_uri=pulumi.get(__ret__, 'http_api_uri'), + http_api_uris=pulumi.get(__ret__, 'http_api_uris'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + management=pulumi.get(__ret__, 'management'), + password=pulumi.get(__ret__, 'password'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + uri=pulumi.get(__ret__, 'uri'), + uris=pulumi.get(__ret__, 'uris'), + username=pulumi.get(__ret__, 'username')) +def get_rabbitmq_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetRabbitmqCredentialResult]: + """ + RabbitMQ credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the RabbitMQ instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getRabbitmqCredential:getRabbitmqCredential', __args__, opts=opts, typ=GetRabbitmqCredentialResult) + return __ret__.apply(lambda __response__: GetRabbitmqCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + host=pulumi.get(__response__, 'host'), + hosts=pulumi.get(__response__, 'hosts'), + http_api_uri=pulumi.get(__response__, 'http_api_uri'), + http_api_uris=pulumi.get(__response__, 'http_api_uris'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + management=pulumi.get(__response__, 'management'), + password=pulumi.get(__response__, 'password'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + uri=pulumi.get(__response__, 'uri'), + uris=pulumi.get(__response__, 'uris'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_rabbitmq_instance.py b/sdk/python/pulumi_stackit/get_rabbitmq_instance.py new file mode 100644 index 0000000..40a519f --- /dev/null +++ b/sdk/python/pulumi_stackit/get_rabbitmq_instance.py @@ -0,0 +1,239 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetRabbitmqInstanceResult', + 'AwaitableGetRabbitmqInstanceResult', + 'get_rabbitmq_instance', + 'get_rabbitmq_instance_output', +] + +@pulumi.output_type +class GetRabbitmqInstanceResult: + """ + A collection of values returned by getRabbitmqInstance. + """ + def __init__(__self__, cf_guid=None, cf_organization_guid=None, cf_space_guid=None, dashboard_url=None, id=None, image_url=None, instance_id=None, name=None, parameters=None, plan_id=None, plan_name=None, project_id=None, version=None): + if cf_guid and not isinstance(cf_guid, str): + raise TypeError("Expected argument 'cf_guid' to be a str") + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid and not isinstance(cf_organization_guid, str): + raise TypeError("Expected argument 'cf_organization_guid' to be a str") + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid and not isinstance(cf_space_guid, str): + raise TypeError("Expected argument 'cf_space_guid' to be a str") + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_url and not isinstance(image_url, str): + raise TypeError("Expected argument 'image_url' to be a str") + pulumi.set(__self__, "image_url", image_url) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> builtins.str: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> builtins.str: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> builtins.str: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> builtins.str: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> 'outputs.GetRabbitmqInstanceParametersResult': + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + The service version. + """ + return pulumi.get(self, "version") + + +class AwaitableGetRabbitmqInstanceResult(GetRabbitmqInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetRabbitmqInstanceResult( + cf_guid=self.cf_guid, + cf_organization_guid=self.cf_organization_guid, + cf_space_guid=self.cf_space_guid, + dashboard_url=self.dashboard_url, + id=self.id, + image_url=self.image_url, + instance_id=self.instance_id, + name=self.name, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + version=self.version) + + +def get_rabbitmq_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRabbitmqInstanceResult: + """ + RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the RabbitMQ instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getRabbitmqInstance:getRabbitmqInstance', __args__, opts=opts, typ=GetRabbitmqInstanceResult).value + + return AwaitableGetRabbitmqInstanceResult( + cf_guid=pulumi.get(__ret__, 'cf_guid'), + cf_organization_guid=pulumi.get(__ret__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__ret__, 'cf_space_guid'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + id=pulumi.get(__ret__, 'id'), + image_url=pulumi.get(__ret__, 'image_url'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + version=pulumi.get(__ret__, 'version')) +def get_rabbitmq_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetRabbitmqInstanceResult]: + """ + RabbitMQ instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the RabbitMQ instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getRabbitmqInstance:getRabbitmqInstance', __args__, opts=opts, typ=GetRabbitmqInstanceResult) + return __ret__.apply(lambda __response__: GetRabbitmqInstanceResult( + cf_guid=pulumi.get(__response__, 'cf_guid'), + cf_organization_guid=pulumi.get(__response__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__response__, 'cf_space_guid'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + id=pulumi.get(__response__, 'id'), + image_url=pulumi.get(__response__, 'image_url'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_redis_credential.py b/sdk/python/pulumi_stackit/get_redis_credential.py new file mode 100644 index 0000000..4d02dbd --- /dev/null +++ b/sdk/python/pulumi_stackit/get_redis_credential.py @@ -0,0 +1,216 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetRedisCredentialResult', + 'AwaitableGetRedisCredentialResult', + 'get_redis_credential', + 'get_redis_credential_output', +] + +@pulumi.output_type +class GetRedisCredentialResult: + """ + A collection of values returned by getRedisCredential. + """ + def __init__(__self__, credential_id=None, host=None, hosts=None, id=None, instance_id=None, load_balanced_host=None, password=None, port=None, project_id=None, uri=None, username=None): + if credential_id and not isinstance(credential_id, str): + raise TypeError("Expected argument 'credential_id' to be a str") + pulumi.set(__self__, "credential_id", credential_id) + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if hosts and not isinstance(hosts, list): + raise TypeError("Expected argument 'hosts' to be a list") + pulumi.set(__self__, "hosts", hosts) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if load_balanced_host and not isinstance(load_balanced_host, str): + raise TypeError("Expected argument 'load_balanced_host' to be a str") + pulumi.set(__self__, "load_balanced_host", load_balanced_host) + if password and not isinstance(password, str): + raise TypeError("Expected argument 'password' to be a str") + pulumi.set(__self__, "password", password) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if uri and not isinstance(uri, str): + raise TypeError("Expected argument 'uri' to be a str") + pulumi.set(__self__, "uri", uri) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> builtins.str: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> Sequence[builtins.str]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="loadBalancedHost") + def load_balanced_host(self) -> builtins.str: + return pulumi.get(self, "load_balanced_host") + + @property + @pulumi.getter + def password(self) -> builtins.str: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> builtins.str: + """ + Connection URI. + """ + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> builtins.str: + return pulumi.get(self, "username") + + +class AwaitableGetRedisCredentialResult(GetRedisCredentialResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetRedisCredentialResult( + credential_id=self.credential_id, + host=self.host, + hosts=self.hosts, + id=self.id, + instance_id=self.instance_id, + load_balanced_host=self.load_balanced_host, + password=self.password, + port=self.port, + project_id=self.project_id, + uri=self.uri, + username=self.username) + + +def get_redis_credential(credential_id: Optional[builtins.str] = None, + instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRedisCredentialResult: + """ + Redis credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the Redis instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getRedisCredential:getRedisCredential', __args__, opts=opts, typ=GetRedisCredentialResult).value + + return AwaitableGetRedisCredentialResult( + credential_id=pulumi.get(__ret__, 'credential_id'), + host=pulumi.get(__ret__, 'host'), + hosts=pulumi.get(__ret__, 'hosts'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + load_balanced_host=pulumi.get(__ret__, 'load_balanced_host'), + password=pulumi.get(__ret__, 'password'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + uri=pulumi.get(__ret__, 'uri'), + username=pulumi.get(__ret__, 'username')) +def get_redis_credential_output(credential_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetRedisCredentialResult]: + """ + Redis credential data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str credential_id: The credential's ID. + :param builtins.str instance_id: ID of the Redis instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['credentialId'] = credential_id + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getRedisCredential:getRedisCredential', __args__, opts=opts, typ=GetRedisCredentialResult) + return __ret__.apply(lambda __response__: GetRedisCredentialResult( + credential_id=pulumi.get(__response__, 'credential_id'), + host=pulumi.get(__response__, 'host'), + hosts=pulumi.get(__response__, 'hosts'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + load_balanced_host=pulumi.get(__response__, 'load_balanced_host'), + password=pulumi.get(__response__, 'password'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + uri=pulumi.get(__response__, 'uri'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_redis_instance.py b/sdk/python/pulumi_stackit/get_redis_instance.py new file mode 100644 index 0000000..317ce2f --- /dev/null +++ b/sdk/python/pulumi_stackit/get_redis_instance.py @@ -0,0 +1,239 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetRedisInstanceResult', + 'AwaitableGetRedisInstanceResult', + 'get_redis_instance', + 'get_redis_instance_output', +] + +@pulumi.output_type +class GetRedisInstanceResult: + """ + A collection of values returned by getRedisInstance. + """ + def __init__(__self__, cf_guid=None, cf_organization_guid=None, cf_space_guid=None, dashboard_url=None, id=None, image_url=None, instance_id=None, name=None, parameters=None, plan_id=None, plan_name=None, project_id=None, version=None): + if cf_guid and not isinstance(cf_guid, str): + raise TypeError("Expected argument 'cf_guid' to be a str") + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid and not isinstance(cf_organization_guid, str): + raise TypeError("Expected argument 'cf_organization_guid' to be a str") + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid and not isinstance(cf_space_guid, str): + raise TypeError("Expected argument 'cf_space_guid' to be a str") + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url and not isinstance(dashboard_url, str): + raise TypeError("Expected argument 'dashboard_url' to be a str") + pulumi.set(__self__, "dashboard_url", dashboard_url) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_url and not isinstance(image_url, str): + raise TypeError("Expected argument 'image_url' to be a str") + pulumi.set(__self__, "image_url", image_url) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if parameters and not isinstance(parameters, dict): + raise TypeError("Expected argument 'parameters' to be a dict") + pulumi.set(__self__, "parameters", parameters) + if plan_id and not isinstance(plan_id, str): + raise TypeError("Expected argument 'plan_id' to be a str") + pulumi.set(__self__, "plan_id", plan_id) + if plan_name and not isinstance(plan_name, str): + raise TypeError("Expected argument 'plan_name' to be a str") + pulumi.set(__self__, "plan_name", plan_name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> builtins.str: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> builtins.str: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> builtins.str: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> builtins.str: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> builtins.str: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> 'outputs.GetRedisInstanceParametersResult': + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> builtins.str: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> builtins.str: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> builtins.str: + """ + The service version. + """ + return pulumi.get(self, "version") + + +class AwaitableGetRedisInstanceResult(GetRedisInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetRedisInstanceResult( + cf_guid=self.cf_guid, + cf_organization_guid=self.cf_organization_guid, + cf_space_guid=self.cf_space_guid, + dashboard_url=self.dashboard_url, + id=self.id, + image_url=self.image_url, + instance_id=self.instance_id, + name=self.name, + parameters=self.parameters, + plan_id=self.plan_id, + plan_name=self.plan_name, + project_id=self.project_id, + version=self.version) + + +def get_redis_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetRedisInstanceResult: + """ + Redis instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Redis instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getRedisInstance:getRedisInstance', __args__, opts=opts, typ=GetRedisInstanceResult).value + + return AwaitableGetRedisInstanceResult( + cf_guid=pulumi.get(__ret__, 'cf_guid'), + cf_organization_guid=pulumi.get(__ret__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__ret__, 'cf_space_guid'), + dashboard_url=pulumi.get(__ret__, 'dashboard_url'), + id=pulumi.get(__ret__, 'id'), + image_url=pulumi.get(__ret__, 'image_url'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + parameters=pulumi.get(__ret__, 'parameters'), + plan_id=pulumi.get(__ret__, 'plan_id'), + plan_name=pulumi.get(__ret__, 'plan_name'), + project_id=pulumi.get(__ret__, 'project_id'), + version=pulumi.get(__ret__, 'version')) +def get_redis_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetRedisInstanceResult]: + """ + Redis instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Redis instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getRedisInstance:getRedisInstance', __args__, opts=opts, typ=GetRedisInstanceResult) + return __ret__.apply(lambda __response__: GetRedisInstanceResult( + cf_guid=pulumi.get(__response__, 'cf_guid'), + cf_organization_guid=pulumi.get(__response__, 'cf_organization_guid'), + cf_space_guid=pulumi.get(__response__, 'cf_space_guid'), + dashboard_url=pulumi.get(__response__, 'dashboard_url'), + id=pulumi.get(__response__, 'id'), + image_url=pulumi.get(__response__, 'image_url'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + parameters=pulumi.get(__response__, 'parameters'), + plan_id=pulumi.get(__response__, 'plan_id'), + plan_name=pulumi.get(__response__, 'plan_name'), + project_id=pulumi.get(__response__, 'project_id'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_resourcemanager_project.py b/sdk/python/pulumi_stackit/get_resourcemanager_project.py new file mode 100644 index 0000000..b8b6adf --- /dev/null +++ b/sdk/python/pulumi_stackit/get_resourcemanager_project.py @@ -0,0 +1,158 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetResourcemanagerProjectResult', + 'AwaitableGetResourcemanagerProjectResult', + 'get_resourcemanager_project', + 'get_resourcemanager_project_output', +] + +@pulumi.output_type +class GetResourcemanagerProjectResult: + """ + A collection of values returned by getResourcemanagerProject. + """ + def __init__(__self__, container_id=None, id=None, labels=None, name=None, parent_container_id=None, project_id=None): + if container_id and not isinstance(container_id, str): + raise TypeError("Expected argument 'container_id' to be a str") + pulumi.set(__self__, "container_id", container_id) + 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, dict): + raise TypeError("Expected argument 'labels' to be a dict") + 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_container_id and not isinstance(parent_container_id, str): + raise TypeError("Expected argument 'parent_container_id' to be a str") + pulumi.set(__self__, "parent_container_id", parent_container_id) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="containerId") + def container_id(self) -> Optional[builtins.str]: + """ + Project container ID. Globally unique, user-friendly identifier. + """ + return pulumi.get(self, "container_id") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64} + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Project name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="parentContainerId") + def parent_container_id(self) -> builtins.str: + """ + Parent resource identifier. Both container ID (user-friendly) and UUID are supported + """ + return pulumi.get(self, "parent_container_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[builtins.str]: + """ + Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + return pulumi.get(self, "project_id") + + +class AwaitableGetResourcemanagerProjectResult(GetResourcemanagerProjectResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetResourcemanagerProjectResult( + container_id=self.container_id, + id=self.id, + labels=self.labels, + name=self.name, + parent_container_id=self.parent_container_id, + project_id=self.project_id) + + +def get_resourcemanager_project(container_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetResourcemanagerProjectResult: + """ + Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used. + + ## Example Usage + + + :param builtins.str container_id: Project container ID. Globally unique, user-friendly identifier. + :param builtins.str project_id: Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + __args__ = dict() + __args__['containerId'] = container_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getResourcemanagerProject:getResourcemanagerProject', __args__, opts=opts, typ=GetResourcemanagerProjectResult).value + + return AwaitableGetResourcemanagerProjectResult( + container_id=pulumi.get(__ret__, 'container_id'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + parent_container_id=pulumi.get(__ret__, 'parent_container_id'), + project_id=pulumi.get(__ret__, 'project_id')) +def get_resourcemanager_project_output(container_id: Optional[pulumi.Input[Optional[builtins.str]]] = None, + project_id: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetResourcemanagerProjectResult]: + """ + Resource Manager project data source schema. To identify the project, you need to provider either project_id or container_id. If you provide both, project_id will be used. + + ## Example Usage + + + :param builtins.str container_id: Project container ID. Globally unique, user-friendly identifier. + :param builtins.str project_id: Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + __args__ = dict() + __args__['containerId'] = container_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getResourcemanagerProject:getResourcemanagerProject', __args__, opts=opts, typ=GetResourcemanagerProjectResult) + return __ret__.apply(lambda __response__: GetResourcemanagerProjectResult( + container_id=pulumi.get(__response__, 'container_id'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + name=pulumi.get(__response__, 'name'), + parent_container_id=pulumi.get(__response__, 'parent_container_id'), + project_id=pulumi.get(__response__, 'project_id'))) diff --git a/sdk/python/pulumi_stackit/get_secretsmanager_instance.py b/sdk/python/pulumi_stackit/get_secretsmanager_instance.py new file mode 100644 index 0000000..609d530 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_secretsmanager_instance.py @@ -0,0 +1,144 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetSecretsmanagerInstanceResult', + 'AwaitableGetSecretsmanagerInstanceResult', + 'get_secretsmanager_instance', + 'get_secretsmanager_instance_output', +] + +@pulumi.output_type +class GetSecretsmanagerInstanceResult: + """ + A collection of values returned by getSecretsmanagerInstance. + """ + def __init__(__self__, acls=None, id=None, instance_id=None, name=None, project_id=None): + if acls and not isinstance(acls, list): + raise TypeError("Expected argument 'acls' to be a list") + pulumi.set(__self__, "acls", acls) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + +class AwaitableGetSecretsmanagerInstanceResult(GetSecretsmanagerInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSecretsmanagerInstanceResult( + acls=self.acls, + id=self.id, + instance_id=self.instance_id, + name=self.name, + project_id=self.project_id) + + +def get_secretsmanager_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSecretsmanagerInstanceResult: + """ + Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Secrets Manager instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance', __args__, opts=opts, typ=GetSecretsmanagerInstanceResult).value + + return AwaitableGetSecretsmanagerInstanceResult( + acls=pulumi.get(__ret__, 'acls'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id')) +def get_secretsmanager_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSecretsmanagerInstanceResult]: + """ + Secrets Manager instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Secrets Manager instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSecretsmanagerInstance:getSecretsmanagerInstance', __args__, opts=opts, typ=GetSecretsmanagerInstanceResult) + return __ret__.apply(lambda __response__: GetSecretsmanagerInstanceResult( + acls=pulumi.get(__response__, 'acls'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'))) diff --git a/sdk/python/pulumi_stackit/get_secretsmanager_user.py b/sdk/python/pulumi_stackit/get_secretsmanager_user.py new file mode 100644 index 0000000..ac46553 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_secretsmanager_user.py @@ -0,0 +1,178 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetSecretsmanagerUserResult', + 'AwaitableGetSecretsmanagerUserResult', + 'get_secretsmanager_user', + 'get_secretsmanager_user_output', +] + +@pulumi.output_type +class GetSecretsmanagerUserResult: + """ + A collection of values returned by getSecretsmanagerUser. + """ + def __init__(__self__, description=None, id=None, instance_id=None, project_id=None, user_id=None, username=None, write_enabled=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 instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if user_id and not isinstance(user_id, str): + raise TypeError("Expected argument 'user_id' to be a str") + pulumi.set(__self__, "user_id", user_id) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + if write_enabled and not isinstance(write_enabled, bool): + raise TypeError("Expected argument 'write_enabled' to be a bool") + pulumi.set(__self__, "write_enabled", write_enabled) + + @property + @pulumi.getter + def description(self) -> builtins.str: + """ + A user chosen description to differentiate between multiple users. Can't be changed after creation. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> builtins.str: + """ + The user's ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> builtins.str: + """ + An auto-generated user name. + """ + return pulumi.get(self, "username") + + @property + @pulumi.getter(name="writeEnabled") + def write_enabled(self) -> builtins.bool: + """ + If true, the user has writeaccess to the secrets engine. + """ + return pulumi.get(self, "write_enabled") + + +class AwaitableGetSecretsmanagerUserResult(GetSecretsmanagerUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSecretsmanagerUserResult( + description=self.description, + id=self.id, + instance_id=self.instance_id, + project_id=self.project_id, + user_id=self.user_id, + username=self.username, + write_enabled=self.write_enabled) + + +def get_secretsmanager_user(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + user_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSecretsmanagerUserResult: + """ + Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Secrets Manager instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + :param builtins.str user_id: The user's ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSecretsmanagerUser:getSecretsmanagerUser', __args__, opts=opts, typ=GetSecretsmanagerUserResult).value + + return AwaitableGetSecretsmanagerUserResult( + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + project_id=pulumi.get(__ret__, 'project_id'), + user_id=pulumi.get(__ret__, 'user_id'), + username=pulumi.get(__ret__, 'username'), + write_enabled=pulumi.get(__ret__, 'write_enabled')) +def get_secretsmanager_user_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSecretsmanagerUserResult]: + """ + Secrets Manager user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the Secrets Manager instance. + :param builtins.str project_id: STACKIT Project ID to which the instance is associated. + :param builtins.str user_id: The user's ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSecretsmanagerUser:getSecretsmanagerUser', __args__, opts=opts, typ=GetSecretsmanagerUserResult) + return __ret__.apply(lambda __response__: GetSecretsmanagerUserResult( + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + project_id=pulumi.get(__response__, 'project_id'), + user_id=pulumi.get(__response__, 'user_id'), + username=pulumi.get(__response__, 'username'), + write_enabled=pulumi.get(__response__, 'write_enabled'))) diff --git a/sdk/python/pulumi_stackit/get_security_group.py b/sdk/python/pulumi_stackit/get_security_group.py new file mode 100644 index 0000000..4d11e3d --- /dev/null +++ b/sdk/python/pulumi_stackit/get_security_group.py @@ -0,0 +1,172 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetSecurityGroupResult', + 'AwaitableGetSecurityGroupResult', + 'get_security_group', + 'get_security_group_output', +] + +@pulumi.output_type +class GetSecurityGroupResult: + """ + A collection of values returned by getSecurityGroup. + """ + def __init__(__self__, description=None, id=None, labels=None, name=None, project_id=None, security_group_id=None, stateful=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 labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + 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 project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if security_group_id and not isinstance(security_group_id, str): + raise TypeError("Expected argument 'security_group_id' to be a str") + pulumi.set(__self__, "security_group_id", security_group_id) + if stateful and not isinstance(stateful, bool): + raise TypeError("Expected argument 'stateful' to be a bool") + pulumi.set(__self__, "stateful", stateful) + + @property + @pulumi.getter + def description(self) -> builtins.str: + """ + The description of the security group. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the security group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the security group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> builtins.str: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @property + @pulumi.getter + def stateful(self) -> builtins.bool: + """ + Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + return pulumi.get(self, "stateful") + + +class AwaitableGetSecurityGroupResult(GetSecurityGroupResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSecurityGroupResult( + description=self.description, + id=self.id, + labels=self.labels, + name=self.name, + project_id=self.project_id, + security_group_id=self.security_group_id, + stateful=self.stateful) + + +def get_security_group(project_id: Optional[builtins.str] = None, + security_group_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSecurityGroupResult: + """ + Security group datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the security group is associated. + :param builtins.str security_group_id: The security group ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['securityGroupId'] = security_group_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSecurityGroup:getSecurityGroup', __args__, opts=opts, typ=GetSecurityGroupResult).value + + return AwaitableGetSecurityGroupResult( + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + security_group_id=pulumi.get(__ret__, 'security_group_id'), + stateful=pulumi.get(__ret__, 'stateful')) +def get_security_group_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSecurityGroupResult]: + """ + Security group datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the security group is associated. + :param builtins.str security_group_id: The security group ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['securityGroupId'] = security_group_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSecurityGroup:getSecurityGroup', __args__, opts=opts, typ=GetSecurityGroupResult) + return __ret__.apply(lambda __response__: GetSecurityGroupResult( + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + security_group_id=pulumi.get(__response__, 'security_group_id'), + stateful=pulumi.get(__response__, 'stateful'))) diff --git a/sdk/python/pulumi_stackit/get_security_group_rule.py b/sdk/python/pulumi_stackit/get_security_group_rule.py new file mode 100644 index 0000000..c33372b --- /dev/null +++ b/sdk/python/pulumi_stackit/get_security_group_rule.py @@ -0,0 +1,249 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetSecurityGroupRuleResult', + 'AwaitableGetSecurityGroupRuleResult', + 'get_security_group_rule', + 'get_security_group_rule_output', +] + +@pulumi.output_type +class GetSecurityGroupRuleResult: + """ + A collection of values returned by getSecurityGroupRule. + """ + def __init__(__self__, description=None, direction=None, ether_type=None, icmp_parameters=None, id=None, ip_range=None, port_range=None, project_id=None, protocol=None, remote_security_group_id=None, security_group_id=None, security_group_rule_id=None): + if description and not isinstance(description, str): + raise TypeError("Expected argument 'description' to be a str") + pulumi.set(__self__, "description", description) + if direction and not isinstance(direction, str): + raise TypeError("Expected argument 'direction' to be a str") + pulumi.set(__self__, "direction", direction) + if ether_type and not isinstance(ether_type, str): + raise TypeError("Expected argument 'ether_type' to be a str") + pulumi.set(__self__, "ether_type", ether_type) + if icmp_parameters and not isinstance(icmp_parameters, dict): + raise TypeError("Expected argument 'icmp_parameters' to be a dict") + pulumi.set(__self__, "icmp_parameters", icmp_parameters) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if ip_range and not isinstance(ip_range, str): + raise TypeError("Expected argument 'ip_range' to be a str") + pulumi.set(__self__, "ip_range", ip_range) + if port_range and not isinstance(port_range, dict): + raise TypeError("Expected argument 'port_range' to be a dict") + pulumi.set(__self__, "port_range", port_range) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if protocol and not isinstance(protocol, dict): + raise TypeError("Expected argument 'protocol' to be a dict") + pulumi.set(__self__, "protocol", protocol) + if remote_security_group_id and not isinstance(remote_security_group_id, str): + raise TypeError("Expected argument 'remote_security_group_id' to be a str") + pulumi.set(__self__, "remote_security_group_id", remote_security_group_id) + if security_group_id and not isinstance(security_group_id, str): + raise TypeError("Expected argument 'security_group_id' to be a str") + pulumi.set(__self__, "security_group_id", security_group_id) + if security_group_rule_id and not isinstance(security_group_rule_id, str): + raise TypeError("Expected argument 'security_group_rule_id' to be a str") + pulumi.set(__self__, "security_group_rule_id", security_group_rule_id) + + @property + @pulumi.getter + def description(self) -> builtins.str: + """ + The description of the security group rule. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def direction(self) -> builtins.str: + """ + The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + """ + return pulumi.get(self, "direction") + + @property + @pulumi.getter(name="etherType") + def ether_type(self) -> builtins.str: + """ + The ethertype which the rule should match. + """ + return pulumi.get(self, "ether_type") + + @property + @pulumi.getter(name="icmpParameters") + def icmp_parameters(self) -> 'outputs.GetSecurityGroupRuleIcmpParametersResult': + """ + ICMP Parameters. + """ + return pulumi.get(self, "icmp_parameters") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="ipRange") + def ip_range(self) -> builtins.str: + """ + The remote IP range which the rule should match. + """ + return pulumi.get(self, "ip_range") + + @property + @pulumi.getter(name="portRange") + def port_range(self) -> 'outputs.GetSecurityGroupRulePortRangeResult': + """ + The range of ports. + """ + return pulumi.get(self, "port_range") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the security group rule is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def protocol(self) -> 'outputs.GetSecurityGroupRuleProtocolResult': + """ + The internet protocol which the rule should match. + """ + return pulumi.get(self, "protocol") + + @property + @pulumi.getter(name="remoteSecurityGroupId") + def remote_security_group_id(self) -> builtins.str: + """ + The remote security group which the rule should match. + """ + return pulumi.get(self, "remote_security_group_id") + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> builtins.str: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @property + @pulumi.getter(name="securityGroupRuleId") + def security_group_rule_id(self) -> builtins.str: + """ + The security group rule ID. + """ + return pulumi.get(self, "security_group_rule_id") + + +class AwaitableGetSecurityGroupRuleResult(GetSecurityGroupRuleResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSecurityGroupRuleResult( + description=self.description, + direction=self.direction, + ether_type=self.ether_type, + icmp_parameters=self.icmp_parameters, + id=self.id, + ip_range=self.ip_range, + port_range=self.port_range, + project_id=self.project_id, + protocol=self.protocol, + remote_security_group_id=self.remote_security_group_id, + security_group_id=self.security_group_id, + security_group_rule_id=self.security_group_rule_id) + + +def get_security_group_rule(project_id: Optional[builtins.str] = None, + security_group_id: Optional[builtins.str] = None, + security_group_rule_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSecurityGroupRuleResult: + """ + Security group datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the security group rule is associated. + :param builtins.str security_group_id: The security group ID. + :param builtins.str security_group_rule_id: The security group rule ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['securityGroupId'] = security_group_id + __args__['securityGroupRuleId'] = security_group_rule_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSecurityGroupRule:getSecurityGroupRule', __args__, opts=opts, typ=GetSecurityGroupRuleResult).value + + return AwaitableGetSecurityGroupRuleResult( + description=pulumi.get(__ret__, 'description'), + direction=pulumi.get(__ret__, 'direction'), + ether_type=pulumi.get(__ret__, 'ether_type'), + icmp_parameters=pulumi.get(__ret__, 'icmp_parameters'), + id=pulumi.get(__ret__, 'id'), + ip_range=pulumi.get(__ret__, 'ip_range'), + port_range=pulumi.get(__ret__, 'port_range'), + project_id=pulumi.get(__ret__, 'project_id'), + protocol=pulumi.get(__ret__, 'protocol'), + remote_security_group_id=pulumi.get(__ret__, 'remote_security_group_id'), + security_group_id=pulumi.get(__ret__, 'security_group_id'), + security_group_rule_id=pulumi.get(__ret__, 'security_group_rule_id')) +def get_security_group_rule_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_rule_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSecurityGroupRuleResult]: + """ + Security group datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the security group rule is associated. + :param builtins.str security_group_id: The security group ID. + :param builtins.str security_group_rule_id: The security group rule ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['securityGroupId'] = security_group_id + __args__['securityGroupRuleId'] = security_group_rule_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSecurityGroupRule:getSecurityGroupRule', __args__, opts=opts, typ=GetSecurityGroupRuleResult) + return __ret__.apply(lambda __response__: GetSecurityGroupRuleResult( + description=pulumi.get(__response__, 'description'), + direction=pulumi.get(__response__, 'direction'), + ether_type=pulumi.get(__response__, 'ether_type'), + icmp_parameters=pulumi.get(__response__, 'icmp_parameters'), + id=pulumi.get(__response__, 'id'), + ip_range=pulumi.get(__response__, 'ip_range'), + port_range=pulumi.get(__response__, 'port_range'), + project_id=pulumi.get(__response__, 'project_id'), + protocol=pulumi.get(__response__, 'protocol'), + remote_security_group_id=pulumi.get(__response__, 'remote_security_group_id'), + security_group_id=pulumi.get(__response__, 'security_group_id'), + security_group_rule_id=pulumi.get(__response__, 'security_group_rule_id'))) diff --git a/sdk/python/pulumi_stackit/get_server.py b/sdk/python/pulumi_stackit/get_server.py new file mode 100644 index 0000000..3b65c1c --- /dev/null +++ b/sdk/python/pulumi_stackit/get_server.py @@ -0,0 +1,299 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetServerResult', + 'AwaitableGetServerResult', + 'get_server', + 'get_server_output', +] + +@pulumi.output_type +class GetServerResult: + """ + A collection of values returned by getServer. + """ + def __init__(__self__, affinity_group=None, availability_zone=None, boot_volume=None, created_at=None, id=None, image_id=None, keypair_name=None, labels=None, launched_at=None, machine_type=None, name=None, network_interfaces=None, project_id=None, server_id=None, updated_at=None, user_data=None): + if affinity_group and not isinstance(affinity_group, str): + raise TypeError("Expected argument 'affinity_group' to be a str") + pulumi.set(__self__, "affinity_group", affinity_group) + if availability_zone and not isinstance(availability_zone, str): + raise TypeError("Expected argument 'availability_zone' to be a str") + pulumi.set(__self__, "availability_zone", availability_zone) + if boot_volume and not isinstance(boot_volume, dict): + raise TypeError("Expected argument 'boot_volume' to be a dict") + pulumi.set(__self__, "boot_volume", boot_volume) + if created_at and not isinstance(created_at, str): + raise TypeError("Expected argument 'created_at' to be a str") + pulumi.set(__self__, "created_at", created_at) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if image_id and not isinstance(image_id, str): + raise TypeError("Expected argument 'image_id' to be a str") + pulumi.set(__self__, "image_id", image_id) + if keypair_name and not isinstance(keypair_name, str): + raise TypeError("Expected argument 'keypair_name' to be a str") + pulumi.set(__self__, "keypair_name", keypair_name) + if labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + pulumi.set(__self__, "labels", labels) + if launched_at and not isinstance(launched_at, str): + raise TypeError("Expected argument 'launched_at' to be a str") + pulumi.set(__self__, "launched_at", launched_at) + if machine_type and not isinstance(machine_type, str): + raise TypeError("Expected argument 'machine_type' to be a str") + pulumi.set(__self__, "machine_type", machine_type) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if network_interfaces and not isinstance(network_interfaces, list): + raise TypeError("Expected argument 'network_interfaces' to be a list") + pulumi.set(__self__, "network_interfaces", network_interfaces) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + if updated_at and not isinstance(updated_at, str): + raise TypeError("Expected argument 'updated_at' to be a str") + pulumi.set(__self__, "updated_at", updated_at) + if user_data and not isinstance(user_data, str): + raise TypeError("Expected argument 'user_data' to be a str") + pulumi.set(__self__, "user_data", user_data) + + @property + @pulumi.getter(name="affinityGroup") + def affinity_group(self) -> builtins.str: + """ + The affinity group the server is assigned to. + """ + return pulumi.get(self, "affinity_group") + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> builtins.str: + """ + The availability zone of the server. + """ + return pulumi.get(self, "availability_zone") + + @property + @pulumi.getter(name="bootVolume") + def boot_volume(self) -> 'outputs.GetServerBootVolumeResult': + """ + The boot volume for the server + """ + return pulumi.get(self, "boot_volume") + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> builtins.str: + """ + Date-time when the server was created + """ + return pulumi.get(self, "created_at") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> builtins.str: + """ + The image ID to be used for an ephemeral disk on the server. + """ + return pulumi.get(self, "image_id") + + @property + @pulumi.getter(name="keypairName") + def keypair_name(self) -> builtins.str: + """ + The name of the keypair used during server creation. + """ + return pulumi.get(self, "keypair_name") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="launchedAt") + def launched_at(self) -> builtins.str: + """ + Date-time when the server was launched + """ + return pulumi.get(self, "launched_at") + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> builtins.str: + """ + Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + """ + return pulumi.get(self, "machine_type") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the server. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkInterfaces") + def network_interfaces(self) -> Sequence[builtins.str]: + """ + The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + """ + return pulumi.get(self, "network_interfaces") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> builtins.str: + """ + Date-time when the server was updated + """ + return pulumi.get(self, "updated_at") + + @property + @pulumi.getter(name="userData") + def user_data(self) -> builtins.str: + """ + User data that is passed via cloud-init to the server. + """ + return pulumi.get(self, "user_data") + + +class AwaitableGetServerResult(GetServerResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServerResult( + affinity_group=self.affinity_group, + availability_zone=self.availability_zone, + boot_volume=self.boot_volume, + created_at=self.created_at, + id=self.id, + image_id=self.image_id, + keypair_name=self.keypair_name, + labels=self.labels, + launched_at=self.launched_at, + machine_type=self.machine_type, + name=self.name, + network_interfaces=self.network_interfaces, + project_id=self.project_id, + server_id=self.server_id, + updated_at=self.updated_at, + user_data=self.user_data) + + +def get_server(project_id: Optional[builtins.str] = None, + server_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServerResult: + """ + Server datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the server is associated. + :param builtins.str server_id: The server ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['serverId'] = server_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServer:getServer', __args__, opts=opts, typ=GetServerResult).value + + return AwaitableGetServerResult( + affinity_group=pulumi.get(__ret__, 'affinity_group'), + availability_zone=pulumi.get(__ret__, 'availability_zone'), + boot_volume=pulumi.get(__ret__, 'boot_volume'), + created_at=pulumi.get(__ret__, 'created_at'), + id=pulumi.get(__ret__, 'id'), + image_id=pulumi.get(__ret__, 'image_id'), + keypair_name=pulumi.get(__ret__, 'keypair_name'), + labels=pulumi.get(__ret__, 'labels'), + launched_at=pulumi.get(__ret__, 'launched_at'), + machine_type=pulumi.get(__ret__, 'machine_type'), + name=pulumi.get(__ret__, 'name'), + network_interfaces=pulumi.get(__ret__, 'network_interfaces'), + project_id=pulumi.get(__ret__, 'project_id'), + server_id=pulumi.get(__ret__, 'server_id'), + updated_at=pulumi.get(__ret__, 'updated_at'), + user_data=pulumi.get(__ret__, 'user_data')) +def get_server_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServerResult]: + """ + Server datasource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the server is associated. + :param builtins.str server_id: The server ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['serverId'] = server_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServer:getServer', __args__, opts=opts, typ=GetServerResult) + return __ret__.apply(lambda __response__: GetServerResult( + affinity_group=pulumi.get(__response__, 'affinity_group'), + availability_zone=pulumi.get(__response__, 'availability_zone'), + boot_volume=pulumi.get(__response__, 'boot_volume'), + created_at=pulumi.get(__response__, 'created_at'), + id=pulumi.get(__response__, 'id'), + image_id=pulumi.get(__response__, 'image_id'), + keypair_name=pulumi.get(__response__, 'keypair_name'), + labels=pulumi.get(__response__, 'labels'), + launched_at=pulumi.get(__response__, 'launched_at'), + machine_type=pulumi.get(__response__, 'machine_type'), + name=pulumi.get(__response__, 'name'), + network_interfaces=pulumi.get(__response__, 'network_interfaces'), + project_id=pulumi.get(__response__, 'project_id'), + server_id=pulumi.get(__response__, 'server_id'), + updated_at=pulumi.get(__response__, 'updated_at'), + user_data=pulumi.get(__response__, 'user_data'))) diff --git a/sdk/python/pulumi_stackit/get_server_backup_schedule.py b/sdk/python/pulumi_stackit/get_server_backup_schedule.py new file mode 100644 index 0000000..fadcafc --- /dev/null +++ b/sdk/python/pulumi_stackit/get_server_backup_schedule.py @@ -0,0 +1,217 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetServerBackupScheduleResult', + 'AwaitableGetServerBackupScheduleResult', + 'get_server_backup_schedule', + 'get_server_backup_schedule_output', +] + +@pulumi.output_type +class GetServerBackupScheduleResult: + """ + A collection of values returned by getServerBackupSchedule. + """ + def __init__(__self__, backup_properties=None, backup_schedule_id=None, enabled=None, id=None, name=None, project_id=None, region=None, rrule=None, server_id=None): + if backup_properties and not isinstance(backup_properties, dict): + raise TypeError("Expected argument 'backup_properties' to be a dict") + pulumi.set(__self__, "backup_properties", backup_properties) + if backup_schedule_id and not isinstance(backup_schedule_id, int): + raise TypeError("Expected argument 'backup_schedule_id' to be a int") + pulumi.set(__self__, "backup_schedule_id", backup_schedule_id) + if enabled and not isinstance(enabled, bool): + raise TypeError("Expected argument 'enabled' to be a bool") + pulumi.set(__self__, "enabled", enabled) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if rrule and not isinstance(rrule, str): + raise TypeError("Expected argument 'rrule' to be a str") + pulumi.set(__self__, "rrule", rrule) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter(name="backupProperties") + def backup_properties(self) -> 'outputs.GetServerBackupScheduleBackupPropertiesResult': + """ + Backup schedule details for the backups. + """ + return pulumi.get(self, "backup_properties") + + @property + @pulumi.getter(name="backupScheduleId") + def backup_schedule_id(self) -> builtins.int: + """ + Backup schedule ID. + """ + return pulumi.get(self, "backup_schedule_id") + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is the backup schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def rrule(self) -> builtins.str: + """ + Backup schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + Server ID for the backup schedule. + """ + return pulumi.get(self, "server_id") + + +class AwaitableGetServerBackupScheduleResult(GetServerBackupScheduleResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServerBackupScheduleResult( + backup_properties=self.backup_properties, + backup_schedule_id=self.backup_schedule_id, + enabled=self.enabled, + id=self.id, + name=self.name, + project_id=self.project_id, + region=self.region, + rrule=self.rrule, + server_id=self.server_id) + + +def get_server_backup_schedule(backup_schedule_id: Optional[builtins.int] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + server_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServerBackupScheduleResult: + """ + Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.int backup_schedule_id: Backup schedule ID. + :param builtins.str project_id: STACKIT Project ID to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID for the backup schedule. + """ + __args__ = dict() + __args__['backupScheduleId'] = backup_schedule_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServerBackupSchedule:getServerBackupSchedule', __args__, opts=opts, typ=GetServerBackupScheduleResult).value + + return AwaitableGetServerBackupScheduleResult( + backup_properties=pulumi.get(__ret__, 'backup_properties'), + backup_schedule_id=pulumi.get(__ret__, 'backup_schedule_id'), + enabled=pulumi.get(__ret__, 'enabled'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + rrule=pulumi.get(__ret__, 'rrule'), + server_id=pulumi.get(__ret__, 'server_id')) +def get_server_backup_schedule_output(backup_schedule_id: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServerBackupScheduleResult]: + """ + Server backup schedule datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.int backup_schedule_id: Backup schedule ID. + :param builtins.str project_id: STACKIT Project ID to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID for the backup schedule. + """ + __args__ = dict() + __args__['backupScheduleId'] = backup_schedule_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServerBackupSchedule:getServerBackupSchedule', __args__, opts=opts, typ=GetServerBackupScheduleResult) + return __ret__.apply(lambda __response__: GetServerBackupScheduleResult( + backup_properties=pulumi.get(__response__, 'backup_properties'), + backup_schedule_id=pulumi.get(__response__, 'backup_schedule_id'), + enabled=pulumi.get(__response__, 'enabled'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + rrule=pulumi.get(__response__, 'rrule'), + server_id=pulumi.get(__response__, 'server_id'))) diff --git a/sdk/python/pulumi_stackit/get_server_backup_schedules.py b/sdk/python/pulumi_stackit/get_server_backup_schedules.py new file mode 100644 index 0000000..cd44323 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_server_backup_schedules.py @@ -0,0 +1,152 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetServerBackupSchedulesResult', + 'AwaitableGetServerBackupSchedulesResult', + 'get_server_backup_schedules', + 'get_server_backup_schedules_output', +] + +@pulumi.output_type +class GetServerBackupSchedulesResult: + """ + A collection of values returned by getServerBackupSchedules. + """ + def __init__(__self__, id=None, items=None, project_id=None, region=None, server_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if items and not isinstance(items, list): + raise TypeError("Expected argument 'items' to be a list") + pulumi.set(__self__, "items", items) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def items(self) -> Sequence['outputs.GetServerBackupSchedulesItemResult']: + return pulumi.get(self, "items") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID (UUID) to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + Server ID (UUID) to which the backup schedule is associated. + """ + return pulumi.get(self, "server_id") + + +class AwaitableGetServerBackupSchedulesResult(GetServerBackupSchedulesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServerBackupSchedulesResult( + id=self.id, + items=self.items, + project_id=self.project_id, + region=self.region, + server_id=self.server_id) + + +def get_server_backup_schedules(project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + server_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServerBackupSchedulesResult: + """ + Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID (UUID) to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID (UUID) to which the backup schedule is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServerBackupSchedules:getServerBackupSchedules', __args__, opts=opts, typ=GetServerBackupSchedulesResult).value + + return AwaitableGetServerBackupSchedulesResult( + id=pulumi.get(__ret__, 'id'), + items=pulumi.get(__ret__, 'items'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + server_id=pulumi.get(__ret__, 'server_id')) +def get_server_backup_schedules_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServerBackupSchedulesResult]: + """ + Server backup schedules datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID (UUID) to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID (UUID) to which the backup schedule is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServerBackupSchedules:getServerBackupSchedules', __args__, opts=opts, typ=GetServerBackupSchedulesResult) + return __ret__.apply(lambda __response__: GetServerBackupSchedulesResult( + id=pulumi.get(__response__, 'id'), + items=pulumi.get(__response__, 'items'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + server_id=pulumi.get(__response__, 'server_id'))) diff --git a/sdk/python/pulumi_stackit/get_server_update_schedule.py b/sdk/python/pulumi_stackit/get_server_update_schedule.py new file mode 100644 index 0000000..689a002 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_server_update_schedule.py @@ -0,0 +1,216 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetServerUpdateScheduleResult', + 'AwaitableGetServerUpdateScheduleResult', + 'get_server_update_schedule', + 'get_server_update_schedule_output', +] + +@pulumi.output_type +class GetServerUpdateScheduleResult: + """ + A collection of values returned by getServerUpdateSchedule. + """ + def __init__(__self__, enabled=None, id=None, maintenance_window=None, name=None, project_id=None, region=None, rrule=None, server_id=None, update_schedule_id=None): + if enabled and not isinstance(enabled, bool): + raise TypeError("Expected argument 'enabled' to be a bool") + pulumi.set(__self__, "enabled", enabled) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if maintenance_window and not isinstance(maintenance_window, int): + raise TypeError("Expected argument 'maintenance_window' to be a int") + pulumi.set(__self__, "maintenance_window", maintenance_window) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if rrule and not isinstance(rrule, str): + raise TypeError("Expected argument 'rrule' to be a str") + pulumi.set(__self__, "rrule", rrule) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + if update_schedule_id and not isinstance(update_schedule_id, int): + raise TypeError("Expected argument 'update_schedule_id' to be a int") + pulumi.set(__self__, "update_schedule_id", update_schedule_id) + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is the update schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="maintenanceWindow") + def maintenance_window(self) -> builtins.int: + """ + Maintenance window [1..24]. + """ + return pulumi.get(self, "maintenance_window") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def rrule(self) -> builtins.str: + """ + Update schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + Server ID for the update schedule. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="updateScheduleId") + def update_schedule_id(self) -> builtins.int: + """ + Update schedule ID. + """ + return pulumi.get(self, "update_schedule_id") + + +class AwaitableGetServerUpdateScheduleResult(GetServerUpdateScheduleResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServerUpdateScheduleResult( + enabled=self.enabled, + id=self.id, + maintenance_window=self.maintenance_window, + name=self.name, + project_id=self.project_id, + region=self.region, + rrule=self.rrule, + server_id=self.server_id, + update_schedule_id=self.update_schedule_id) + + +def get_server_update_schedule(project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + server_id: Optional[builtins.str] = None, + update_schedule_id: Optional[builtins.int] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServerUpdateScheduleResult: + """ + Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID for the update schedule. + :param builtins.int update_schedule_id: Update schedule ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + __args__['updateScheduleId'] = update_schedule_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServerUpdateSchedule:getServerUpdateSchedule', __args__, opts=opts, typ=GetServerUpdateScheduleResult).value + + return AwaitableGetServerUpdateScheduleResult( + enabled=pulumi.get(__ret__, 'enabled'), + id=pulumi.get(__ret__, 'id'), + maintenance_window=pulumi.get(__ret__, 'maintenance_window'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + rrule=pulumi.get(__ret__, 'rrule'), + server_id=pulumi.get(__ret__, 'server_id'), + update_schedule_id=pulumi.get(__ret__, 'update_schedule_id')) +def get_server_update_schedule_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + update_schedule_id: Optional[pulumi.Input[builtins.int]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServerUpdateScheduleResult]: + """ + Server update schedule datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID for the update schedule. + :param builtins.int update_schedule_id: Update schedule ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + __args__['updateScheduleId'] = update_schedule_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServerUpdateSchedule:getServerUpdateSchedule', __args__, opts=opts, typ=GetServerUpdateScheduleResult) + return __ret__.apply(lambda __response__: GetServerUpdateScheduleResult( + enabled=pulumi.get(__response__, 'enabled'), + id=pulumi.get(__response__, 'id'), + maintenance_window=pulumi.get(__response__, 'maintenance_window'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + rrule=pulumi.get(__response__, 'rrule'), + server_id=pulumi.get(__response__, 'server_id'), + update_schedule_id=pulumi.get(__response__, 'update_schedule_id'))) diff --git a/sdk/python/pulumi_stackit/get_server_update_schedules.py b/sdk/python/pulumi_stackit/get_server_update_schedules.py new file mode 100644 index 0000000..b468290 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_server_update_schedules.py @@ -0,0 +1,152 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetServerUpdateSchedulesResult', + 'AwaitableGetServerUpdateSchedulesResult', + 'get_server_update_schedules', + 'get_server_update_schedules_output', +] + +@pulumi.output_type +class GetServerUpdateSchedulesResult: + """ + A collection of values returned by getServerUpdateSchedules. + """ + def __init__(__self__, id=None, items=None, project_id=None, region=None, server_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if items and not isinstance(items, list): + raise TypeError("Expected argument 'items' to be a list") + pulumi.set(__self__, "items", items) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def items(self) -> Sequence['outputs.GetServerUpdateSchedulesItemResult']: + return pulumi.get(self, "items") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT Project ID (UUID) to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + Server ID (UUID) to which the update schedule is associated. + """ + return pulumi.get(self, "server_id") + + +class AwaitableGetServerUpdateSchedulesResult(GetServerUpdateSchedulesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServerUpdateSchedulesResult( + id=self.id, + items=self.items, + project_id=self.project_id, + region=self.region, + server_id=self.server_id) + + +def get_server_update_schedules(project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + server_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServerUpdateSchedulesResult: + """ + Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID (UUID) to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID (UUID) to which the update schedule is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServerUpdateSchedules:getServerUpdateSchedules', __args__, opts=opts, typ=GetServerUpdateSchedulesResult).value + + return AwaitableGetServerUpdateSchedulesResult( + id=pulumi.get(__ret__, 'id'), + items=pulumi.get(__ret__, 'items'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + server_id=pulumi.get(__ret__, 'server_id')) +def get_server_update_schedules_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServerUpdateSchedulesResult]: + """ + Server update schedules datasource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + + :param builtins.str project_id: STACKIT Project ID (UUID) to which the server is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str server_id: Server ID (UUID) to which the update schedule is associated. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['region'] = region + __args__['serverId'] = server_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServerUpdateSchedules:getServerUpdateSchedules', __args__, opts=opts, typ=GetServerUpdateSchedulesResult) + return __ret__.apply(lambda __response__: GetServerUpdateSchedulesResult( + id=pulumi.get(__response__, 'id'), + items=pulumi.get(__response__, 'items'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + server_id=pulumi.get(__response__, 'server_id'))) diff --git a/sdk/python/pulumi_stackit/get_service_account.py b/sdk/python/pulumi_stackit/get_service_account.py new file mode 100644 index 0000000..e0b23aa --- /dev/null +++ b/sdk/python/pulumi_stackit/get_service_account.py @@ -0,0 +1,130 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetServiceAccountResult', + 'AwaitableGetServiceAccountResult', + 'get_service_account', + 'get_service_account_output', +] + +@pulumi.output_type +class GetServiceAccountResult: + """ + A collection of values returned by getServiceAccount. + """ + def __init__(__self__, email=None, id=None, name=None, project_id=None): + if email and not isinstance(email, str): + raise TypeError("Expected argument 'email' to be a str") + pulumi.set(__self__, "email", email) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter + def email(self) -> builtins.str: + """ + Email of the service account. + """ + return pulumi.get(self, "email") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Name of the service account. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the service account is associated. + """ + return pulumi.get(self, "project_id") + + +class AwaitableGetServiceAccountResult(GetServiceAccountResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetServiceAccountResult( + email=self.email, + id=self.id, + name=self.name, + project_id=self.project_id) + + +def get_service_account(email: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetServiceAccountResult: + """ + Service account data source schema. + + ## Example Usage + + + :param builtins.str email: Email of the service account. + :param builtins.str project_id: STACKIT project ID to which the service account is associated. + """ + __args__ = dict() + __args__['email'] = email + __args__['projectId'] = project_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getServiceAccount:getServiceAccount', __args__, opts=opts, typ=GetServiceAccountResult).value + + return AwaitableGetServiceAccountResult( + email=pulumi.get(__ret__, 'email'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + project_id=pulumi.get(__ret__, 'project_id')) +def get_service_account_output(email: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetServiceAccountResult]: + """ + Service account data source schema. + + ## Example Usage + + + :param builtins.str email: Email of the service account. + :param builtins.str project_id: STACKIT project ID to which the service account is associated. + """ + __args__ = dict() + __args__['email'] = email + __args__['projectId'] = project_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getServiceAccount:getServiceAccount', __args__, opts=opts, typ=GetServiceAccountResult) + return __ret__.apply(lambda __response__: GetServiceAccountResult( + email=pulumi.get(__response__, 'email'), + id=pulumi.get(__response__, 'id'), + name=pulumi.get(__response__, 'name'), + project_id=pulumi.get(__response__, 'project_id'))) diff --git a/sdk/python/pulumi_stackit/get_ske_cluster.py b/sdk/python/pulumi_stackit/get_ske_cluster.py new file mode 100644 index 0000000..e9ef8e9 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_ske_cluster.py @@ -0,0 +1,281 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetSkeClusterResult', + 'AwaitableGetSkeClusterResult', + 'get_ske_cluster', + 'get_ske_cluster_output', +] + +@pulumi.output_type +class GetSkeClusterResult: + """ + A collection of values returned by getSkeCluster. + """ + def __init__(__self__, allow_privileged_containers=None, egress_address_ranges=None, extensions=None, hibernations=None, id=None, kubernetes_version=None, kubernetes_version_min=None, kubernetes_version_used=None, maintenance=None, name=None, network=None, node_pools=None, project_id=None, region=None): + if allow_privileged_containers and not isinstance(allow_privileged_containers, bool): + raise TypeError("Expected argument 'allow_privileged_containers' to be a bool") + pulumi.set(__self__, "allow_privileged_containers", allow_privileged_containers) + if egress_address_ranges and not isinstance(egress_address_ranges, list): + raise TypeError("Expected argument 'egress_address_ranges' to be a list") + pulumi.set(__self__, "egress_address_ranges", egress_address_ranges) + if extensions and not isinstance(extensions, dict): + raise TypeError("Expected argument 'extensions' to be a dict") + pulumi.set(__self__, "extensions", extensions) + if hibernations and not isinstance(hibernations, list): + raise TypeError("Expected argument 'hibernations' to be a list") + pulumi.set(__self__, "hibernations", hibernations) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if kubernetes_version and not isinstance(kubernetes_version, str): + raise TypeError("Expected argument 'kubernetes_version' to be a str") + pulumi.set(__self__, "kubernetes_version", kubernetes_version) + if kubernetes_version_min and not isinstance(kubernetes_version_min, str): + raise TypeError("Expected argument 'kubernetes_version_min' to be a str") + pulumi.set(__self__, "kubernetes_version_min", kubernetes_version_min) + if kubernetes_version_used and not isinstance(kubernetes_version_used, str): + raise TypeError("Expected argument 'kubernetes_version_used' to be a str") + pulumi.set(__self__, "kubernetes_version_used", kubernetes_version_used) + if maintenance and not isinstance(maintenance, dict): + raise TypeError("Expected argument 'maintenance' to be a dict") + pulumi.set(__self__, "maintenance", maintenance) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if network and not isinstance(network, dict): + raise TypeError("Expected argument 'network' to be a dict") + pulumi.set(__self__, "network", network) + if node_pools and not isinstance(node_pools, list): + raise TypeError("Expected argument 'node_pools' to be a list") + pulumi.set(__self__, "node_pools", node_pools) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="allowPrivilegedContainers") + @_utilities.deprecated("""Please remove this flag from your configuration when using Kubernetes version 1.25+.""") + def allow_privileged_containers(self) -> builtins.bool: + """ + DEPRECATED as of Kubernetes 1.25+ + Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + """ + return pulumi.get(self, "allow_privileged_containers") + + @property + @pulumi.getter(name="egressAddressRanges") + def egress_address_ranges(self) -> Sequence[builtins.str]: + """ + The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + """ + return pulumi.get(self, "egress_address_ranges") + + @property + @pulumi.getter + def extensions(self) -> 'outputs.GetSkeClusterExtensionsResult': + """ + A single extensions block as defined below + """ + return pulumi.get(self, "extensions") + + @property + @pulumi.getter + def hibernations(self) -> Sequence['outputs.GetSkeClusterHibernationResult']: + """ + One or more hibernation block as defined below. + """ + return pulumi.get(self, "hibernations") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="kubernetesVersion") + @_utilities.deprecated("""This field is always nil, use `kubernetes_version_used` to get the cluster kubernetes version. This field would cause errors when the cluster got a kubernetes version minor upgrade, either triggered by automatic or forceful updates.""") + def kubernetes_version(self) -> builtins.str: + """ + Kubernetes version. This field is deprecated, use `kubernetes_version_used` instead + """ + return pulumi.get(self, "kubernetes_version") + + @property + @pulumi.getter(name="kubernetesVersionMin") + def kubernetes_version_min(self) -> builtins.str: + """ + The minimum Kubernetes version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the `kubernetes_version_used` field. + """ + return pulumi.get(self, "kubernetes_version_min") + + @property + @pulumi.getter(name="kubernetesVersionUsed") + def kubernetes_version_used(self) -> builtins.str: + """ + Full Kubernetes version used. For example, if `1.22` was selected, this value may result to `1.22.15` + """ + return pulumi.get(self, "kubernetes_version_used") + + @property + @pulumi.getter + def maintenance(self) -> 'outputs.GetSkeClusterMaintenanceResult': + """ + A single maintenance block as defined below + """ + return pulumi.get(self, "maintenance") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The cluster name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def network(self) -> 'outputs.GetSkeClusterNetworkResult': + """ + Network block as defined below. + """ + return pulumi.get(self, "network") + + @property + @pulumi.getter(name="nodePools") + def node_pools(self) -> Sequence['outputs.GetSkeClusterNodePoolResult']: + """ + One or more `node_pool` block as defined below. + """ + return pulumi.get(self, "node_pools") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + +class AwaitableGetSkeClusterResult(GetSkeClusterResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSkeClusterResult( + allow_privileged_containers=self.allow_privileged_containers, + egress_address_ranges=self.egress_address_ranges, + extensions=self.extensions, + hibernations=self.hibernations, + id=self.id, + kubernetes_version=self.kubernetes_version, + kubernetes_version_min=self.kubernetes_version_min, + kubernetes_version_used=self.kubernetes_version_used, + maintenance=self.maintenance, + name=self.name, + network=self.network, + node_pools=self.node_pools, + project_id=self.project_id, + region=self.region) + + +def get_ske_cluster(name: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSkeClusterResult: + """ + SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The cluster name. + :param builtins.str project_id: STACKIT project ID to which the cluster is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSkeCluster:getSkeCluster', __args__, opts=opts, typ=GetSkeClusterResult).value + + return AwaitableGetSkeClusterResult( + allow_privileged_containers=pulumi.get(__ret__, 'allow_privileged_containers'), + egress_address_ranges=pulumi.get(__ret__, 'egress_address_ranges'), + extensions=pulumi.get(__ret__, 'extensions'), + hibernations=pulumi.get(__ret__, 'hibernations'), + id=pulumi.get(__ret__, 'id'), + kubernetes_version=pulumi.get(__ret__, 'kubernetes_version'), + kubernetes_version_min=pulumi.get(__ret__, 'kubernetes_version_min'), + kubernetes_version_used=pulumi.get(__ret__, 'kubernetes_version_used'), + maintenance=pulumi.get(__ret__, 'maintenance'), + name=pulumi.get(__ret__, 'name'), + network=pulumi.get(__ret__, 'network'), + node_pools=pulumi.get(__ret__, 'node_pools'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region')) +def get_ske_cluster_output(name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSkeClusterResult]: + """ + SKE Cluster data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str name: The cluster name. + :param builtins.str project_id: STACKIT project ID to which the cluster is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['name'] = name + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSkeCluster:getSkeCluster', __args__, opts=opts, typ=GetSkeClusterResult) + return __ret__.apply(lambda __response__: GetSkeClusterResult( + allow_privileged_containers=pulumi.get(__response__, 'allow_privileged_containers'), + egress_address_ranges=pulumi.get(__response__, 'egress_address_ranges'), + extensions=pulumi.get(__response__, 'extensions'), + hibernations=pulumi.get(__response__, 'hibernations'), + id=pulumi.get(__response__, 'id'), + kubernetes_version=pulumi.get(__response__, 'kubernetes_version'), + kubernetes_version_min=pulumi.get(__response__, 'kubernetes_version_min'), + kubernetes_version_used=pulumi.get(__response__, 'kubernetes_version_used'), + maintenance=pulumi.get(__response__, 'maintenance'), + name=pulumi.get(__response__, 'name'), + network=pulumi.get(__response__, 'network'), + node_pools=pulumi.get(__response__, 'node_pools'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'))) diff --git a/sdk/python/pulumi_stackit/get_sqlserverflex_instance.py b/sdk/python/pulumi_stackit/get_sqlserverflex_instance.py new file mode 100644 index 0000000..5f43477 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_sqlserverflex_instance.py @@ -0,0 +1,237 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetSqlserverflexInstanceResult', + 'AwaitableGetSqlserverflexInstanceResult', + 'get_sqlserverflex_instance', + 'get_sqlserverflex_instance_output', +] + +@pulumi.output_type +class GetSqlserverflexInstanceResult: + """ + A collection of values returned by getSqlserverflexInstance. + """ + def __init__(__self__, acls=None, backup_schedule=None, flavor=None, id=None, instance_id=None, name=None, options=None, project_id=None, region=None, replicas=None, storage=None, version=None): + if acls and not isinstance(acls, list): + raise TypeError("Expected argument 'acls' to be a list") + pulumi.set(__self__, "acls", acls) + if backup_schedule and not isinstance(backup_schedule, str): + raise TypeError("Expected argument 'backup_schedule' to be a str") + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor and not isinstance(flavor, dict): + raise TypeError("Expected argument 'flavor' to be a dict") + pulumi.set(__self__, "flavor", flavor) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if options and not isinstance(options, dict): + raise TypeError("Expected argument 'options' to be a dict") + pulumi.set(__self__, "options", options) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if replicas and not isinstance(replicas, int): + raise TypeError("Expected argument 'replicas' to be a int") + pulumi.set(__self__, "replicas", replicas) + if storage and not isinstance(storage, dict): + raise TypeError("Expected argument 'storage' to be a dict") + pulumi.set(__self__, "storage", storage) + if version and not isinstance(version, str): + raise TypeError("Expected argument 'version' to be a str") + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + The Access Control List (ACL) for the SQLServer Flex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> builtins.str: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + """ + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> 'outputs.GetSqlserverflexInstanceFlavorResult': + return pulumi.get(self, "flavor") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def options(self) -> 'outputs.GetSqlserverflexInstanceOptionsResult': + """ + Custom parameters for the SQLServer Flex instance. + """ + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def replicas(self) -> builtins.int: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> 'outputs.GetSqlserverflexInstanceStorageResult': + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> builtins.str: + return pulumi.get(self, "version") + + +class AwaitableGetSqlserverflexInstanceResult(GetSqlserverflexInstanceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSqlserverflexInstanceResult( + acls=self.acls, + backup_schedule=self.backup_schedule, + flavor=self.flavor, + id=self.id, + instance_id=self.instance_id, + name=self.name, + options=self.options, + project_id=self.project_id, + region=self.region, + replicas=self.replicas, + storage=self.storage, + version=self.version) + + +def get_sqlserverflex_instance(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSqlserverflexInstanceResult: + """ + SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the SQLServer Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSqlserverflexInstance:getSqlserverflexInstance', __args__, opts=opts, typ=GetSqlserverflexInstanceResult).value + + return AwaitableGetSqlserverflexInstanceResult( + acls=pulumi.get(__ret__, 'acls'), + backup_schedule=pulumi.get(__ret__, 'backup_schedule'), + flavor=pulumi.get(__ret__, 'flavor'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + name=pulumi.get(__ret__, 'name'), + options=pulumi.get(__ret__, 'options'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + replicas=pulumi.get(__ret__, 'replicas'), + storage=pulumi.get(__ret__, 'storage'), + version=pulumi.get(__ret__, 'version')) +def get_sqlserverflex_instance_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSqlserverflexInstanceResult]: + """ + SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the SQLServer Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSqlserverflexInstance:getSqlserverflexInstance', __args__, opts=opts, typ=GetSqlserverflexInstanceResult) + return __ret__.apply(lambda __response__: GetSqlserverflexInstanceResult( + acls=pulumi.get(__response__, 'acls'), + backup_schedule=pulumi.get(__response__, 'backup_schedule'), + flavor=pulumi.get(__response__, 'flavor'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + name=pulumi.get(__response__, 'name'), + options=pulumi.get(__response__, 'options'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + replicas=pulumi.get(__response__, 'replicas'), + storage=pulumi.get(__response__, 'storage'), + version=pulumi.get(__response__, 'version'))) diff --git a/sdk/python/pulumi_stackit/get_sqlserverflex_user.py b/sdk/python/pulumi_stackit/get_sqlserverflex_user.py new file mode 100644 index 0000000..57a94f1 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_sqlserverflex_user.py @@ -0,0 +1,206 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = [ + 'GetSqlserverflexUserResult', + 'AwaitableGetSqlserverflexUserResult', + 'get_sqlserverflex_user', + 'get_sqlserverflex_user_output', +] + +@pulumi.output_type +class GetSqlserverflexUserResult: + """ + A collection of values returned by getSqlserverflexUser. + """ + def __init__(__self__, host=None, id=None, instance_id=None, port=None, project_id=None, region=None, roles=None, user_id=None, username=None): + if host and not isinstance(host, str): + raise TypeError("Expected argument 'host' to be a str") + pulumi.set(__self__, "host", host) + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if instance_id and not isinstance(instance_id, str): + raise TypeError("Expected argument 'instance_id' to be a str") + pulumi.set(__self__, "instance_id", instance_id) + if port and not isinstance(port, int): + raise TypeError("Expected argument 'port' to be a int") + pulumi.set(__self__, "port", port) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if region and not isinstance(region, str): + raise TypeError("Expected argument 'region' to be a str") + pulumi.set(__self__, "region", region) + if roles and not isinstance(roles, list): + raise TypeError("Expected argument 'roles' to be a list") + pulumi.set(__self__, "roles", roles) + if user_id and not isinstance(user_id, str): + raise TypeError("Expected argument 'user_id' to be a str") + pulumi.set(__self__, "user_id", user_id) + if username and not isinstance(username, str): + raise TypeError("Expected argument 'username' to be a str") + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def host(self) -> builtins.str: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> builtins.str: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def port(self) -> builtins.int: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> Optional[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def roles(self) -> Sequence[builtins.str]: + """ + Database access levels for the user. + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> builtins.str: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> builtins.str: + """ + Username of the SQLServer Flex instance. + """ + return pulumi.get(self, "username") + + +class AwaitableGetSqlserverflexUserResult(GetSqlserverflexUserResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetSqlserverflexUserResult( + host=self.host, + id=self.id, + instance_id=self.instance_id, + port=self.port, + project_id=self.project_id, + region=self.region, + roles=self.roles, + user_id=self.user_id, + username=self.username) + + +def get_sqlserverflex_user(instance_id: Optional[builtins.str] = None, + project_id: Optional[builtins.str] = None, + region: Optional[builtins.str] = None, + user_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSqlserverflexUserResult: + """ + SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the SQLServer Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['userId'] = user_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getSqlserverflexUser:getSqlserverflexUser', __args__, opts=opts, typ=GetSqlserverflexUserResult).value + + return AwaitableGetSqlserverflexUserResult( + host=pulumi.get(__ret__, 'host'), + id=pulumi.get(__ret__, 'id'), + instance_id=pulumi.get(__ret__, 'instance_id'), + port=pulumi.get(__ret__, 'port'), + project_id=pulumi.get(__ret__, 'project_id'), + region=pulumi.get(__ret__, 'region'), + roles=pulumi.get(__ret__, 'roles'), + user_id=pulumi.get(__ret__, 'user_id'), + username=pulumi.get(__ret__, 'username')) +def get_sqlserverflex_user_output(instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[Optional[builtins.str]]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetSqlserverflexUserResult]: + """ + SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str instance_id: ID of the SQLServer Flex instance. + :param builtins.str project_id: STACKIT project ID to which the instance is associated. + :param builtins.str region: The resource region. If not defined, the provider region is used. + :param builtins.str user_id: User ID. + """ + __args__ = dict() + __args__['instanceId'] = instance_id + __args__['projectId'] = project_id + __args__['region'] = region + __args__['userId'] = user_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getSqlserverflexUser:getSqlserverflexUser', __args__, opts=opts, typ=GetSqlserverflexUserResult) + return __ret__.apply(lambda __response__: GetSqlserverflexUserResult( + host=pulumi.get(__response__, 'host'), + id=pulumi.get(__response__, 'id'), + instance_id=pulumi.get(__response__, 'instance_id'), + port=pulumi.get(__response__, 'port'), + project_id=pulumi.get(__response__, 'project_id'), + region=pulumi.get(__response__, 'region'), + roles=pulumi.get(__response__, 'roles'), + user_id=pulumi.get(__response__, 'user_id'), + username=pulumi.get(__response__, 'username'))) diff --git a/sdk/python/pulumi_stackit/get_volume.py b/sdk/python/pulumi_stackit/get_volume.py new file mode 100644 index 0000000..2d0e074 --- /dev/null +++ b/sdk/python/pulumi_stackit/get_volume.py @@ -0,0 +1,229 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetVolumeResult', + 'AwaitableGetVolumeResult', + 'get_volume', + 'get_volume_output', +] + +@pulumi.output_type +class GetVolumeResult: + """ + A collection of values returned by getVolume. + """ + def __init__(__self__, availability_zone=None, description=None, id=None, labels=None, name=None, performance_class=None, project_id=None, server_id=None, size=None, source=None, volume_id=None): + if availability_zone and not isinstance(availability_zone, str): + raise TypeError("Expected argument 'availability_zone' to be a str") + pulumi.set(__self__, "availability_zone", availability_zone) + 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 labels and not isinstance(labels, dict): + raise TypeError("Expected argument 'labels' to be a dict") + 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 performance_class and not isinstance(performance_class, str): + raise TypeError("Expected argument 'performance_class' to be a str") + pulumi.set(__self__, "performance_class", performance_class) + if project_id and not isinstance(project_id, str): + raise TypeError("Expected argument 'project_id' to be a str") + pulumi.set(__self__, "project_id", project_id) + if server_id and not isinstance(server_id, str): + raise TypeError("Expected argument 'server_id' to be a str") + pulumi.set(__self__, "server_id", server_id) + if size and not isinstance(size, int): + raise TypeError("Expected argument 'size' to be a int") + pulumi.set(__self__, "size", size) + if source and not isinstance(source, dict): + raise TypeError("Expected argument 'source' to be a dict") + pulumi.set(__self__, "source", source) + if volume_id and not isinstance(volume_id, str): + raise TypeError("Expected argument 'volume_id' to be a str") + pulumi.set(__self__, "volume_id", volume_id) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> builtins.str: + """ + The availability zone of the volume. + """ + return pulumi.get(self, "availability_zone") + + @property + @pulumi.getter + def description(self) -> builtins.str: + """ + The description of the volume. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the volume. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> builtins.str: + """ + The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + """ + return pulumi.get(self, "performance_class") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> builtins.str: + """ + STACKIT project ID to which the volume is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> builtins.str: + """ + The server ID of the server to which the volume is attached to. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter + def size(self) -> builtins.int: + """ + The size of the volume in GB. It can only be updated to a larger value than the current size + """ + return pulumi.get(self, "size") + + @property + @pulumi.getter + def source(self) -> 'outputs.GetVolumeSourceResult': + """ + The source of the volume. It can be either a volume, an image, a snapshot or a backup + """ + return pulumi.get(self, "source") + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> builtins.str: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + + +class AwaitableGetVolumeResult(GetVolumeResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetVolumeResult( + availability_zone=self.availability_zone, + description=self.description, + id=self.id, + labels=self.labels, + name=self.name, + performance_class=self.performance_class, + project_id=self.project_id, + server_id=self.server_id, + size=self.size, + source=self.source, + volume_id=self.volume_id) + + +def get_volume(project_id: Optional[builtins.str] = None, + volume_id: Optional[builtins.str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetVolumeResult: + """ + Volume resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the volume is associated. + :param builtins.str volume_id: The volume ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['volumeId'] = volume_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('stackit:index/getVolume:getVolume', __args__, opts=opts, typ=GetVolumeResult).value + + return AwaitableGetVolumeResult( + availability_zone=pulumi.get(__ret__, 'availability_zone'), + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + performance_class=pulumi.get(__ret__, 'performance_class'), + project_id=pulumi.get(__ret__, 'project_id'), + server_id=pulumi.get(__ret__, 'server_id'), + size=pulumi.get(__ret__, 'size'), + source=pulumi.get(__ret__, 'source'), + volume_id=pulumi.get(__ret__, 'volume_id')) +def get_volume_output(project_id: Optional[pulumi.Input[builtins.str]] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None, + opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetVolumeResult]: + """ + Volume resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + + :param builtins.str project_id: STACKIT project ID to which the volume is associated. + :param builtins.str volume_id: The volume ID. + """ + __args__ = dict() + __args__['projectId'] = project_id + __args__['volumeId'] = volume_id + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('stackit:index/getVolume:getVolume', __args__, opts=opts, typ=GetVolumeResult) + return __ret__.apply(lambda __response__: GetVolumeResult( + availability_zone=pulumi.get(__response__, 'availability_zone'), + description=pulumi.get(__response__, 'description'), + id=pulumi.get(__response__, 'id'), + labels=pulumi.get(__response__, 'labels'), + name=pulumi.get(__response__, 'name'), + performance_class=pulumi.get(__response__, 'performance_class'), + project_id=pulumi.get(__response__, 'project_id'), + server_id=pulumi.get(__response__, 'server_id'), + size=pulumi.get(__response__, 'size'), + source=pulumi.get(__response__, 'source'), + volume_id=pulumi.get(__response__, 'volume_id'))) diff --git a/sdk/python/pulumi_stackit/git.py b/sdk/python/pulumi_stackit/git.py new file mode 100644 index 0000000..b1e81af --- /dev/null +++ b/sdk/python/pulumi_stackit/git.py @@ -0,0 +1,292 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['GitArgs', 'Git'] + +@pulumi.input_type +class GitArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a Git resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the git instance is associated. + :param pulumi.Input[builtins.str] name: Unique name linked to the git instance. + """ + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the git instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Unique name linked to the git instance. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _GitState: + def __init__(__self__, *, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + url: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering Git resources. + :param pulumi.Input[builtins.str] instance_id: ID linked to the git instance. + :param pulumi.Input[builtins.str] name: Unique name linked to the git instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the git instance is associated. + :param pulumi.Input[builtins.str] url: Url linked to the git instance. + :param pulumi.Input[builtins.str] version: Version linked to the git instance. + """ + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if url is not None: + pulumi.set(__self__, "url", url) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID linked to the git instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Unique name linked to the git instance. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the git instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Url linked to the git instance. + """ + return pulumi.get(self, "url") + + @url.setter + def url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "url", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Version linked to the git instance. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/git:Git") +class Git(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Git Instance resource schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Unique name linked to the git instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the git instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: GitArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Git Instance resource schema. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param GitArgs 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(GitArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = GitArgs.__new__(GitArgs) + + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["instance_id"] = None + __props__.__dict__["url"] = None + __props__.__dict__["version"] = None + super(Git, __self__).__init__( + 'stackit:index/git:Git', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + url: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'Git': + """ + Get an existing Git 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[builtins.str] instance_id: ID linked to the git instance. + :param pulumi.Input[builtins.str] name: Unique name linked to the git instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the git instance is associated. + :param pulumi.Input[builtins.str] url: Url linked to the git instance. + :param pulumi.Input[builtins.str] version: Version linked to the git instance. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _GitState.__new__(_GitState) + + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["url"] = url + __props__.__dict__["version"] = version + return Git(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID linked to the git instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Unique name linked to the git instance. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the git instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def url(self) -> pulumi.Output[builtins.str]: + """ + Url linked to the git instance. + """ + return pulumi.get(self, "url") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + Version linked to the git instance. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/image.py b/sdk/python/pulumi_stackit/image.py new file mode 100644 index 0000000..153c515 --- /dev/null +++ b/sdk/python/pulumi_stackit/image.py @@ -0,0 +1,602 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ImageArgs', 'Image'] + +@pulumi.input_type +class ImageArgs: + def __init__(__self__, *, + disk_format: pulumi.Input[builtins.str], + local_file_path: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + config: Optional[pulumi.Input['ImageConfigArgs']] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + min_disk_size: Optional[pulumi.Input[builtins.int]] = None, + min_ram: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a Image resource. + :param pulumi.Input[builtins.str] disk_format: The disk format of the image. + :param pulumi.Input[builtins.str] local_file_path: The filepath of the raw image file to be uploaded. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the image is associated. + :param pulumi.Input['ImageConfigArgs'] config: Properties to set hardware and scheduling settings for an image. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.int] min_disk_size: The minimum disk size of the image in GB. + :param pulumi.Input[builtins.int] min_ram: The minimum RAM of the image in MB. + :param pulumi.Input[builtins.str] name: The name of the image. + """ + pulumi.set(__self__, "disk_format", disk_format) + pulumi.set(__self__, "local_file_path", local_file_path) + pulumi.set(__self__, "project_id", project_id) + if config is not None: + pulumi.set(__self__, "config", config) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if min_disk_size is not None: + pulumi.set(__self__, "min_disk_size", min_disk_size) + if min_ram is not None: + pulumi.set(__self__, "min_ram", min_ram) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="diskFormat") + def disk_format(self) -> pulumi.Input[builtins.str]: + """ + The disk format of the image. + """ + return pulumi.get(self, "disk_format") + + @disk_format.setter + def disk_format(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "disk_format", value) + + @property + @pulumi.getter(name="localFilePath") + def local_file_path(self) -> pulumi.Input[builtins.str]: + """ + The filepath of the raw image file to be uploaded. + """ + return pulumi.get(self, "local_file_path") + + @local_file_path.setter + def local_file_path(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "local_file_path", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the image is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ImageConfigArgs']]: + """ + Properties to set hardware and scheduling settings for an image. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ImageConfigArgs']]): + pulumi.set(self, "config", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="minDiskSize") + def min_disk_size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimum disk size of the image in GB. + """ + return pulumi.get(self, "min_disk_size") + + @min_disk_size.setter + def min_disk_size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_disk_size", value) + + @property + @pulumi.getter(name="minRam") + def min_ram(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimum RAM of the image in MB. + """ + return pulumi.get(self, "min_ram") + + @min_ram.setter + def min_ram(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_ram", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the image. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ImageState: + def __init__(__self__, *, + checksum: Optional[pulumi.Input['ImageChecksumArgs']] = None, + config: Optional[pulumi.Input['ImageConfigArgs']] = None, + disk_format: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + local_file_path: Optional[pulumi.Input[builtins.str]] = None, + min_disk_size: Optional[pulumi.Input[builtins.int]] = None, + min_ram: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protected: Optional[pulumi.Input[builtins.bool]] = None, + scope: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering Image resources. + :param pulumi.Input['ImageChecksumArgs'] checksum: Representation of an image checksum. + :param pulumi.Input['ImageConfigArgs'] config: Properties to set hardware and scheduling settings for an image. + :param pulumi.Input[builtins.str] disk_format: The disk format of the image. + :param pulumi.Input[builtins.str] image_id: The image ID. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] local_file_path: The filepath of the raw image file to be uploaded. + :param pulumi.Input[builtins.int] min_disk_size: The minimum disk size of the image in GB. + :param pulumi.Input[builtins.int] min_ram: The minimum RAM of the image in MB. + :param pulumi.Input[builtins.str] name: The name of the image. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the image is associated. + :param pulumi.Input[builtins.bool] protected: Whether the image is protected. + :param pulumi.Input[builtins.str] scope: The scope of the image. + """ + if checksum is not None: + pulumi.set(__self__, "checksum", checksum) + if config is not None: + pulumi.set(__self__, "config", config) + if disk_format is not None: + pulumi.set(__self__, "disk_format", disk_format) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if local_file_path is not None: + pulumi.set(__self__, "local_file_path", local_file_path) + if min_disk_size is not None: + pulumi.set(__self__, "min_disk_size", min_disk_size) + if min_ram is not None: + pulumi.set(__self__, "min_ram", min_ram) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if protected is not None: + pulumi.set(__self__, "protected", protected) + if scope is not None: + pulumi.set(__self__, "scope", scope) + + @property + @pulumi.getter + def checksum(self) -> Optional[pulumi.Input['ImageChecksumArgs']]: + """ + Representation of an image checksum. + """ + return pulumi.get(self, "checksum") + + @checksum.setter + def checksum(self, value: Optional[pulumi.Input['ImageChecksumArgs']]): + pulumi.set(self, "checksum", value) + + @property + @pulumi.getter + def config(self) -> Optional[pulumi.Input['ImageConfigArgs']]: + """ + Properties to set hardware and scheduling settings for an image. + """ + return pulumi.get(self, "config") + + @config.setter + def config(self, value: Optional[pulumi.Input['ImageConfigArgs']]): + pulumi.set(self, "config", value) + + @property + @pulumi.getter(name="diskFormat") + def disk_format(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The disk format of the image. + """ + return pulumi.get(self, "disk_format") + + @disk_format.setter + def disk_format(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "disk_format", value) + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The image ID. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_id", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="localFilePath") + def local_file_path(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The filepath of the raw image file to be uploaded. + """ + return pulumi.get(self, "local_file_path") + + @local_file_path.setter + def local_file_path(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "local_file_path", value) + + @property + @pulumi.getter(name="minDiskSize") + def min_disk_size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimum disk size of the image in GB. + """ + return pulumi.get(self, "min_disk_size") + + @min_disk_size.setter + def min_disk_size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_disk_size", value) + + @property + @pulumi.getter(name="minRam") + def min_ram(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimum RAM of the image in MB. + """ + return pulumi.get(self, "min_ram") + + @min_ram.setter + def min_ram(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_ram", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the image. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the image is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def protected(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Whether the image is protected. + """ + return pulumi.get(self, "protected") + + @protected.setter + def protected(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "protected", value) + + @property + @pulumi.getter + def scope(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The scope of the image. + """ + return pulumi.get(self, "scope") + + @scope.setter + def scope(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scope", value) + + +@pulumi.type_token("stackit:index/image:Image") +class Image(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + config: Optional[pulumi.Input[Union['ImageConfigArgs', 'ImageConfigArgsDict']]] = None, + disk_format: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + local_file_path: Optional[pulumi.Input[builtins.str]] = None, + min_disk_size: Optional[pulumi.Input[builtins.int]] = None, + min_ram: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Image resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ImageConfigArgs', 'ImageConfigArgsDict']] config: Properties to set hardware and scheduling settings for an image. + :param pulumi.Input[builtins.str] disk_format: The disk format of the image. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] local_file_path: The filepath of the raw image file to be uploaded. + :param pulumi.Input[builtins.int] min_disk_size: The minimum disk size of the image in GB. + :param pulumi.Input[builtins.int] min_ram: The minimum RAM of the image in MB. + :param pulumi.Input[builtins.str] name: The name of the image. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the image is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ImageArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Image resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ImageArgs 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(ImageArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + config: Optional[pulumi.Input[Union['ImageConfigArgs', 'ImageConfigArgsDict']]] = None, + disk_format: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + local_file_path: Optional[pulumi.Input[builtins.str]] = None, + min_disk_size: Optional[pulumi.Input[builtins.int]] = None, + min_ram: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = ImageArgs.__new__(ImageArgs) + + __props__.__dict__["config"] = config + if disk_format is None and not opts.urn: + raise TypeError("Missing required property 'disk_format'") + __props__.__dict__["disk_format"] = disk_format + __props__.__dict__["labels"] = labels + if local_file_path is None and not opts.urn: + raise TypeError("Missing required property 'local_file_path'") + __props__.__dict__["local_file_path"] = local_file_path + __props__.__dict__["min_disk_size"] = min_disk_size + __props__.__dict__["min_ram"] = min_ram + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["checksum"] = None + __props__.__dict__["image_id"] = None + __props__.__dict__["protected"] = None + __props__.__dict__["scope"] = None + super(Image, __self__).__init__( + 'stackit:index/image:Image', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + checksum: Optional[pulumi.Input[Union['ImageChecksumArgs', 'ImageChecksumArgsDict']]] = None, + config: Optional[pulumi.Input[Union['ImageConfigArgs', 'ImageConfigArgsDict']]] = None, + disk_format: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + local_file_path: Optional[pulumi.Input[builtins.str]] = None, + min_disk_size: Optional[pulumi.Input[builtins.int]] = None, + min_ram: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protected: Optional[pulumi.Input[builtins.bool]] = None, + scope: Optional[pulumi.Input[builtins.str]] = None) -> 'Image': + """ + Get an existing Image 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[Union['ImageChecksumArgs', 'ImageChecksumArgsDict']] checksum: Representation of an image checksum. + :param pulumi.Input[Union['ImageConfigArgs', 'ImageConfigArgsDict']] config: Properties to set hardware and scheduling settings for an image. + :param pulumi.Input[builtins.str] disk_format: The disk format of the image. + :param pulumi.Input[builtins.str] image_id: The image ID. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] local_file_path: The filepath of the raw image file to be uploaded. + :param pulumi.Input[builtins.int] min_disk_size: The minimum disk size of the image in GB. + :param pulumi.Input[builtins.int] min_ram: The minimum RAM of the image in MB. + :param pulumi.Input[builtins.str] name: The name of the image. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the image is associated. + :param pulumi.Input[builtins.bool] protected: Whether the image is protected. + :param pulumi.Input[builtins.str] scope: The scope of the image. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ImageState.__new__(_ImageState) + + __props__.__dict__["checksum"] = checksum + __props__.__dict__["config"] = config + __props__.__dict__["disk_format"] = disk_format + __props__.__dict__["image_id"] = image_id + __props__.__dict__["labels"] = labels + __props__.__dict__["local_file_path"] = local_file_path + __props__.__dict__["min_disk_size"] = min_disk_size + __props__.__dict__["min_ram"] = min_ram + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["protected"] = protected + __props__.__dict__["scope"] = scope + return Image(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def checksum(self) -> pulumi.Output['outputs.ImageChecksum']: + """ + Representation of an image checksum. + """ + return pulumi.get(self, "checksum") + + @property + @pulumi.getter + def config(self) -> pulumi.Output['outputs.ImageConfig']: + """ + Properties to set hardware and scheduling settings for an image. + """ + return pulumi.get(self, "config") + + @property + @pulumi.getter(name="diskFormat") + def disk_format(self) -> pulumi.Output[builtins.str]: + """ + The disk format of the image. + """ + return pulumi.get(self, "disk_format") + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> pulumi.Output[builtins.str]: + """ + The image ID. + """ + return pulumi.get(self, "image_id") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="localFilePath") + def local_file_path(self) -> pulumi.Output[builtins.str]: + """ + The filepath of the raw image file to be uploaded. + """ + return pulumi.get(self, "local_file_path") + + @property + @pulumi.getter(name="minDiskSize") + def min_disk_size(self) -> pulumi.Output[builtins.int]: + """ + The minimum disk size of the image in GB. + """ + return pulumi.get(self, "min_disk_size") + + @property + @pulumi.getter(name="minRam") + def min_ram(self) -> pulumi.Output[builtins.int]: + """ + The minimum RAM of the image in MB. + """ + return pulumi.get(self, "min_ram") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the image. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the image is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def protected(self) -> pulumi.Output[builtins.bool]: + """ + Whether the image is protected. + """ + return pulumi.get(self, "protected") + + @property + @pulumi.getter + def scope(self) -> pulumi.Output[builtins.str]: + """ + The scope of the image. + """ + return pulumi.get(self, "scope") + diff --git a/sdk/python/pulumi_stackit/key_pair.py b/sdk/python/pulumi_stackit/key_pair.py new file mode 100644 index 0000000..589fcad --- /dev/null +++ b/sdk/python/pulumi_stackit/key_pair.py @@ -0,0 +1,275 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['KeyPairArgs', 'KeyPair'] + +@pulumi.input_type +class KeyPairArgs: + def __init__(__self__, *, + public_key: pulumi.Input[builtins.str], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a KeyPair resource. + :param pulumi.Input[builtins.str] public_key: A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. + :param pulumi.Input[builtins.str] name: The name of the SSH key pair. + """ + pulumi.set(__self__, "public_key", public_key) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> pulumi.Input[builtins.str]: + """ + A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + return pulumi.get(self, "public_key") + + @public_key.setter + def public_key(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "public_key", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the SSH key pair. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _KeyPairState: + def __init__(__self__, *, + fingerprint: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering KeyPair resources. + :param pulumi.Input[builtins.str] fingerprint: The fingerprint of the public SSH key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. + :param pulumi.Input[builtins.str] name: The name of the SSH key pair. + :param pulumi.Input[builtins.str] public_key: A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + if fingerprint is not None: + pulumi.set(__self__, "fingerprint", fingerprint) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if public_key is not None: + pulumi.set(__self__, "public_key", public_key) + + @property + @pulumi.getter + def fingerprint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The fingerprint of the public SSH key. + """ + return pulumi.get(self, "fingerprint") + + @fingerprint.setter + def fingerprint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "fingerprint", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the SSH key pair. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + return pulumi.get(self, "public_key") + + @public_key.setter + def public_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_key", value) + + +@pulumi.type_token("stackit:index/keyPair:KeyPair") +class KeyPair(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. + :param pulumi.Input[builtins.str] name: The name of the SSH key pair. + :param pulumi.Input[builtins.str] public_key: A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: KeyPairArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Key pair resource schema. Must have a `region` specified in the provider configuration. Allows uploading an SSH public key to be used for server authentication. + + :param str resource_name: The name of the resource. + :param KeyPairArgs 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(KeyPairArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.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__ = KeyPairArgs.__new__(KeyPairArgs) + + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + if public_key is None and not opts.urn: + raise TypeError("Missing required property 'public_key'") + __props__.__dict__["public_key"] = public_key + __props__.__dict__["fingerprint"] = None + super(KeyPair, __self__).__init__( + 'stackit:index/keyPair:KeyPair', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + fingerprint: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None) -> 'KeyPair': + """ + Get an existing KeyPair 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[builtins.str] fingerprint: The fingerprint of the public SSH key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. + :param pulumi.Input[builtins.str] name: The name of the SSH key pair. + :param pulumi.Input[builtins.str] public_key: A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _KeyPairState.__new__(_KeyPairState) + + __props__.__dict__["fingerprint"] = fingerprint + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["public_key"] = public_key + return KeyPair(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def fingerprint(self) -> pulumi.Output[builtins.str]: + """ + The fingerprint of the public SSH key. + """ + return pulumi.get(self, "fingerprint") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the SSH key pair. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> pulumi.Output[builtins.str]: + """ + A string representation of the public SSH key. E.g., `ssh-rsa ` or `ssh-ed25519 `. + """ + return pulumi.get(self, "public_key") + diff --git a/sdk/python/pulumi_stackit/loadbalancer.py b/sdk/python/pulumi_stackit/loadbalancer.py new file mode 100644 index 0000000..48b23d3 --- /dev/null +++ b/sdk/python/pulumi_stackit/loadbalancer.py @@ -0,0 +1,515 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['LoadbalancerArgs', 'Loadbalancer'] + +@pulumi.input_type +class LoadbalancerArgs: + def __init__(__self__, *, + listeners: pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]], + networks: pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]], + project_id: pulumi.Input[builtins.str], + target_pools: pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]], + external_address: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input['LoadbalancerOptionsArgs']] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a Loadbalancer resource. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]] listeners: List of all listeners which will accept traffic. Limited to 20. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]] networks: List of networks that listeners and targets reside in. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the Load Balancer is associated. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]] target_pools: List of all target pools which will be used in the Load Balancer. Limited to 20. + :param pulumi.Input[builtins.str] external_address: External Load Balancer IP address where this Load Balancer is exposed. + :param pulumi.Input[builtins.str] name: Load balancer name. + :param pulumi.Input['LoadbalancerOptionsArgs'] options: Defines any optional functionality you want to have enabled on your load balancer. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "listeners", listeners) + pulumi.set(__self__, "networks", networks) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "target_pools", target_pools) + if external_address is not None: + pulumi.set(__self__, "external_address", external_address) + if name is not None: + pulumi.set(__self__, "name", name) + if options is not None: + pulumi.set(__self__, "options", options) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter + def listeners(self) -> pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]]: + """ + List of all listeners which will accept traffic. Limited to 20. + """ + return pulumi.get(self, "listeners") + + @listeners.setter + def listeners(self, value: pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]]): + pulumi.set(self, "listeners", value) + + @property + @pulumi.getter + def networks(self) -> pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]]: + """ + List of networks that listeners and targets reside in. + """ + return pulumi.get(self, "networks") + + @networks.setter + def networks(self, value: pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]]): + pulumi.set(self, "networks", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the Load Balancer is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="targetPools") + def target_pools(self) -> pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]]: + """ + List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + return pulumi.get(self, "target_pools") + + @target_pools.setter + def target_pools(self, value: pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]]): + pulumi.set(self, "target_pools", value) + + @property + @pulumi.getter(name="externalAddress") + def external_address(self) -> Optional[pulumi.Input[builtins.str]]: + """ + External Load Balancer IP address where this Load Balancer is exposed. + """ + return pulumi.get(self, "external_address") + + @external_address.setter + def external_address(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "external_address", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Load balancer name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def options(self) -> Optional[pulumi.Input['LoadbalancerOptionsArgs']]: + """ + Defines any optional functionality you want to have enabled on your load balancer. + """ + return pulumi.get(self, "options") + + @options.setter + def options(self, value: Optional[pulumi.Input['LoadbalancerOptionsArgs']]): + pulumi.set(self, "options", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _LoadbalancerState: + def __init__(__self__, *, + external_address: Optional[pulumi.Input[builtins.str]] = None, + listeners: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + networks: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]]] = None, + options: Optional[pulumi.Input['LoadbalancerOptionsArgs']] = None, + private_address: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + target_pools: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]]] = None): + """ + Input properties used for looking up and filtering Loadbalancer resources. + :param pulumi.Input[builtins.str] external_address: External Load Balancer IP address where this Load Balancer is exposed. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]] listeners: List of all listeners which will accept traffic. Limited to 20. + :param pulumi.Input[builtins.str] name: Load balancer name. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]] networks: List of networks that listeners and targets reside in. + :param pulumi.Input['LoadbalancerOptionsArgs'] options: Defines any optional functionality you want to have enabled on your load balancer. + :param pulumi.Input[builtins.str] private_address: Transient private Load Balancer IP address. It can change any time. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the Load Balancer is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]] target_pools: List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + if external_address is not None: + pulumi.set(__self__, "external_address", external_address) + if listeners is not None: + pulumi.set(__self__, "listeners", listeners) + if name is not None: + pulumi.set(__self__, "name", name) + if networks is not None: + pulumi.set(__self__, "networks", networks) + if options is not None: + pulumi.set(__self__, "options", options) + if private_address is not None: + pulumi.set(__self__, "private_address", private_address) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if target_pools is not None: + pulumi.set(__self__, "target_pools", target_pools) + + @property + @pulumi.getter(name="externalAddress") + def external_address(self) -> Optional[pulumi.Input[builtins.str]]: + """ + External Load Balancer IP address where this Load Balancer is exposed. + """ + return pulumi.get(self, "external_address") + + @external_address.setter + def external_address(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "external_address", value) + + @property + @pulumi.getter + def listeners(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]]]: + """ + List of all listeners which will accept traffic. Limited to 20. + """ + return pulumi.get(self, "listeners") + + @listeners.setter + def listeners(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerListenerArgs']]]]): + pulumi.set(self, "listeners", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Load balancer name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]]]: + """ + List of networks that listeners and targets reside in. + """ + return pulumi.get(self, "networks") + + @networks.setter + def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerNetworkArgs']]]]): + pulumi.set(self, "networks", value) + + @property + @pulumi.getter + def options(self) -> Optional[pulumi.Input['LoadbalancerOptionsArgs']]: + """ + Defines any optional functionality you want to have enabled on your load balancer. + """ + return pulumi.get(self, "options") + + @options.setter + def options(self, value: Optional[pulumi.Input['LoadbalancerOptionsArgs']]): + pulumi.set(self, "options", value) + + @property + @pulumi.getter(name="privateAddress") + def private_address(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Transient private Load Balancer IP address. It can change any time. + """ + return pulumi.get(self, "private_address") + + @private_address.setter + def private_address(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "private_address", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the Load Balancer is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="targetPools") + def target_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]]]: + """ + List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + return pulumi.get(self, "target_pools") + + @target_pools.setter + def target_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadbalancerTargetPoolArgs']]]]): + pulumi.set(self, "target_pools", value) + + +@pulumi.type_token("stackit:index/loadbalancer:Loadbalancer") +class Loadbalancer(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + external_address: Optional[pulumi.Input[builtins.str]] = None, + listeners: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerListenerArgs', 'LoadbalancerListenerArgsDict']]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerNetworkArgs', 'LoadbalancerNetworkArgsDict']]]]] = None, + options: Optional[pulumi.Input[Union['LoadbalancerOptionsArgs', 'LoadbalancerOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + target_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerTargetPoolArgs', 'LoadbalancerTargetPoolArgsDict']]]]] = None, + __props__=None): + """ + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] external_address: External Load Balancer IP address where this Load Balancer is exposed. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerListenerArgs', 'LoadbalancerListenerArgsDict']]]] listeners: List of all listeners which will accept traffic. Limited to 20. + :param pulumi.Input[builtins.str] name: Load balancer name. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerNetworkArgs', 'LoadbalancerNetworkArgsDict']]]] networks: List of networks that listeners and targets reside in. + :param pulumi.Input[Union['LoadbalancerOptionsArgs', 'LoadbalancerOptionsArgsDict']] options: Defines any optional functionality you want to have enabled on your load balancer. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the Load Balancer is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerTargetPoolArgs', 'LoadbalancerTargetPoolArgsDict']]]] target_pools: List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: LoadbalancerArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ## Example Usage + + :param str resource_name: The name of the resource. + :param LoadbalancerArgs 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(LoadbalancerArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + external_address: Optional[pulumi.Input[builtins.str]] = None, + listeners: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerListenerArgs', 'LoadbalancerListenerArgsDict']]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerNetworkArgs', 'LoadbalancerNetworkArgsDict']]]]] = None, + options: Optional[pulumi.Input[Union['LoadbalancerOptionsArgs', 'LoadbalancerOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + target_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerTargetPoolArgs', 'LoadbalancerTargetPoolArgsDict']]]]] = 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__ = LoadbalancerArgs.__new__(LoadbalancerArgs) + + __props__.__dict__["external_address"] = external_address + if listeners is None and not opts.urn: + raise TypeError("Missing required property 'listeners'") + __props__.__dict__["listeners"] = listeners + __props__.__dict__["name"] = name + if networks is None and not opts.urn: + raise TypeError("Missing required property 'networks'") + __props__.__dict__["networks"] = networks + __props__.__dict__["options"] = options + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if target_pools is None and not opts.urn: + raise TypeError("Missing required property 'target_pools'") + __props__.__dict__["target_pools"] = target_pools + __props__.__dict__["private_address"] = None + super(Loadbalancer, __self__).__init__( + 'stackit:index/loadbalancer:Loadbalancer', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + external_address: Optional[pulumi.Input[builtins.str]] = None, + listeners: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerListenerArgs', 'LoadbalancerListenerArgsDict']]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + networks: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerNetworkArgs', 'LoadbalancerNetworkArgsDict']]]]] = None, + options: Optional[pulumi.Input[Union['LoadbalancerOptionsArgs', 'LoadbalancerOptionsArgsDict']]] = None, + private_address: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + target_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerTargetPoolArgs', 'LoadbalancerTargetPoolArgsDict']]]]] = None) -> 'Loadbalancer': + """ + Get an existing Loadbalancer 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[builtins.str] external_address: External Load Balancer IP address where this Load Balancer is exposed. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerListenerArgs', 'LoadbalancerListenerArgsDict']]]] listeners: List of all listeners which will accept traffic. Limited to 20. + :param pulumi.Input[builtins.str] name: Load balancer name. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerNetworkArgs', 'LoadbalancerNetworkArgsDict']]]] networks: List of networks that listeners and targets reside in. + :param pulumi.Input[Union['LoadbalancerOptionsArgs', 'LoadbalancerOptionsArgsDict']] options: Defines any optional functionality you want to have enabled on your load balancer. + :param pulumi.Input[builtins.str] private_address: Transient private Load Balancer IP address. It can change any time. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the Load Balancer is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input[Union['LoadbalancerTargetPoolArgs', 'LoadbalancerTargetPoolArgsDict']]]] target_pools: List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LoadbalancerState.__new__(_LoadbalancerState) + + __props__.__dict__["external_address"] = external_address + __props__.__dict__["listeners"] = listeners + __props__.__dict__["name"] = name + __props__.__dict__["networks"] = networks + __props__.__dict__["options"] = options + __props__.__dict__["private_address"] = private_address + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["target_pools"] = target_pools + return Loadbalancer(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="externalAddress") + def external_address(self) -> pulumi.Output[Optional[builtins.str]]: + """ + External Load Balancer IP address where this Load Balancer is exposed. + """ + return pulumi.get(self, "external_address") + + @property + @pulumi.getter + def listeners(self) -> pulumi.Output[Sequence['outputs.LoadbalancerListener']]: + """ + List of all listeners which will accept traffic. Limited to 20. + """ + return pulumi.get(self, "listeners") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Load balancer name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def networks(self) -> pulumi.Output[Sequence['outputs.LoadbalancerNetwork']]: + """ + List of networks that listeners and targets reside in. + """ + return pulumi.get(self, "networks") + + @property + @pulumi.getter + def options(self) -> pulumi.Output['outputs.LoadbalancerOptions']: + """ + Defines any optional functionality you want to have enabled on your load balancer. + """ + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="privateAddress") + def private_address(self) -> pulumi.Output[builtins.str]: + """ + Transient private Load Balancer IP address. It can change any time. + """ + return pulumi.get(self, "private_address") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the Load Balancer is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="targetPools") + def target_pools(self) -> pulumi.Output[Sequence['outputs.LoadbalancerTargetPool']]: + """ + List of all target pools which will be used in the Load Balancer. Limited to 20. + """ + return pulumi.get(self, "target_pools") + diff --git a/sdk/python/pulumi_stackit/loadbalancer_observability_credential.py b/sdk/python/pulumi_stackit/loadbalancer_observability_credential.py new file mode 100644 index 0000000..7d3733b --- /dev/null +++ b/sdk/python/pulumi_stackit/loadbalancer_observability_credential.py @@ -0,0 +1,376 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['LoadbalancerObservabilityCredentialArgs', 'LoadbalancerObservabilityCredential'] + +@pulumi.input_type +class LoadbalancerObservabilityCredentialArgs: + def __init__(__self__, *, + display_name: pulumi.Input[builtins.str], + password: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + username: pulumi.Input[builtins.str], + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a LoadbalancerObservabilityCredential resource. + :param pulumi.Input[builtins.str] display_name: Observability credential name. + :param pulumi.Input[builtins.str] password: The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the load balancer observability credential is associated. + :param pulumi.Input[builtins.str] username: The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "display_name", display_name) + pulumi.set(__self__, "password", password) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "username", username) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> pulumi.Input[builtins.str]: + """ + Observability credential name. + """ + return pulumi.get(self, "display_name") + + @display_name.setter + def display_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "display_name", value) + + @property + @pulumi.getter + def password(self) -> pulumi.Input[builtins.str]: + """ + The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the load balancer observability credential is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def username(self) -> pulumi.Input[builtins.str]: + """ + The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "username", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _LoadbalancerObservabilityCredentialState: + def __init__(__self__, *, + credentials_ref: Optional[pulumi.Input[builtins.str]] = None, + display_name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering LoadbalancerObservabilityCredential resources. + :param pulumi.Input[builtins.str] credentials_ref: The credentials reference is used by the Load Balancer to define which credentials it will use. + :param pulumi.Input[builtins.str] display_name: Observability credential name. + :param pulumi.Input[builtins.str] password: The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the load balancer observability credential is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] username: The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + if credentials_ref is not None: + pulumi.set(__self__, "credentials_ref", credentials_ref) + if display_name is not None: + pulumi.set(__self__, "display_name", display_name) + if password is not None: + pulumi.set(__self__, "password", password) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credentials reference is used by the Load Balancer to define which credentials it will use. + """ + return pulumi.get(self, "credentials_ref") + + @credentials_ref.setter + def credentials_ref(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_ref", value) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Observability credential name. + """ + return pulumi.get(self, "display_name") + + @display_name.setter + def display_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "display_name", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the load balancer observability credential is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential") +class LoadbalancerObservabilityCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + display_name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] display_name: Observability credential name. + :param pulumi.Input[builtins.str] password: The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the load balancer observability credential is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] username: The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: LoadbalancerObservabilityCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Load balancer observability credential resource schema. Must have a `region` specified in the provider configuration. These contain the username and password for the observability service (e.g. Argus) where the load balancer logs/metrics will be pushed into + + ## Example Usage + + :param str resource_name: The name of the resource. + :param LoadbalancerObservabilityCredentialArgs 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(LoadbalancerObservabilityCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + display_name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.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__ = LoadbalancerObservabilityCredentialArgs.__new__(LoadbalancerObservabilityCredentialArgs) + + if display_name is None and not opts.urn: + raise TypeError("Missing required property 'display_name'") + __props__.__dict__["display_name"] = display_name + if password is None and not opts.urn: + raise TypeError("Missing required property 'password'") + __props__.__dict__["password"] = password + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if username is None and not opts.urn: + raise TypeError("Missing required property 'username'") + __props__.__dict__["username"] = username + __props__.__dict__["credentials_ref"] = None + super(LoadbalancerObservabilityCredential, __self__).__init__( + 'stackit:index/loadbalancerObservabilityCredential:LoadbalancerObservabilityCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credentials_ref: Optional[pulumi.Input[builtins.str]] = None, + display_name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'LoadbalancerObservabilityCredential': + """ + Get an existing LoadbalancerObservabilityCredential 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[builtins.str] credentials_ref: The credentials reference is used by the Load Balancer to define which credentials it will use. + :param pulumi.Input[builtins.str] display_name: Observability credential name. + :param pulumi.Input[builtins.str] password: The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the load balancer observability credential is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] username: The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LoadbalancerObservabilityCredentialState.__new__(_LoadbalancerObservabilityCredentialState) + + __props__.__dict__["credentials_ref"] = credentials_ref + __props__.__dict__["display_name"] = display_name + __props__.__dict__["password"] = password + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["username"] = username + return LoadbalancerObservabilityCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> pulumi.Output[builtins.str]: + """ + The credentials reference is used by the Load Balancer to define which credentials it will use. + """ + return pulumi.get(self, "credentials_ref") + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> pulumi.Output[builtins.str]: + """ + Observability credential name. + """ + return pulumi.get(self, "display_name") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + """ + The username for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the load balancer observability credential is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + """ + The password for the observability service (e.g. Argus) where the logs/metrics will be pushed into. + """ + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/logme_credential.py b/sdk/python/pulumi_stackit/logme_credential.py new file mode 100644 index 0000000..b1432de --- /dev/null +++ b/sdk/python/pulumi_stackit/logme_credential.py @@ -0,0 +1,335 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['LogmeCredentialArgs', 'LogmeCredential'] + +@pulumi.input_type +class LogmeCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a LogmeCredential resource. + :param pulumi.Input[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _LogmeCredentialState: + def __init__(__self__, *, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering LogmeCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if host is not None: + pulumi.set(__self__, "host", host) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/logmeCredential:LogmeCredential") +class LogmeCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + LogMe credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: LogmeCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + LogMe credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param LogmeCredentialArgs 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(LogmeCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = LogmeCredentialArgs.__new__(LogmeCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["credential_id"] = None + __props__.__dict__["host"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(LogmeCredential, __self__).__init__( + 'stackit:index/logmeCredential:LogmeCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'LogmeCredential': + """ + Get an existing LogmeCredential 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[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LogmeCredentialState.__new__(_LogmeCredentialState) + + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["host"] = host + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["uri"] = uri + __props__.__dict__["username"] = username + return LogmeCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/logme_instance.py b/sdk/python/pulumi_stackit/logme_instance.py new file mode 100644 index 0000000..523a55a --- /dev/null +++ b/sdk/python/pulumi_stackit/logme_instance.py @@ -0,0 +1,492 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['LogmeInstanceArgs', 'LogmeInstance'] + +@pulumi.input_type +class LogmeInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['LogmeInstanceParametersArgs']] = None): + """ + The set of arguments for constructing a LogmeInstance resource. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['LogmeInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['LogmeInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _LogmeInstanceState: + def __init__(__self__, *, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['LogmeInstanceParametersArgs']] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering LogmeInstance resources. + :param pulumi.Input[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + if cf_guid is not None: + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid is not None: + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid is not None: + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_guid") + + @cf_guid.setter + def cf_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_guid", value) + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_organization_guid") + + @cf_organization_guid.setter + def cf_organization_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_organization_guid", value) + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_space_guid") + + @cf_space_guid.setter + def cf_space_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_space_guid", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['LogmeInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['LogmeInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/logmeInstance:LogmeInstance") +class LogmeInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['LogmeInstanceParametersArgs', 'LogmeInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + LogMe instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: LogmeInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + LogMe instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param LogmeInstanceArgs 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(LogmeInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['LogmeInstanceParametersArgs', 'LogmeInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.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__ = LogmeInstanceArgs.__new__(LogmeInstanceArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["cf_guid"] = None + __props__.__dict__["cf_organization_guid"] = None + __props__.__dict__["cf_space_guid"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["image_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["plan_id"] = None + super(LogmeInstance, __self__).__init__( + 'stackit:index/logmeInstance:LogmeInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['LogmeInstanceParametersArgs', 'LogmeInstanceParametersArgsDict']]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'LogmeInstance': + """ + Get an existing LogmeInstance 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[builtins.str] instance_id: ID of the LogMe instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _LogmeInstanceState.__new__(_LogmeInstanceState) + + __props__.__dict__["cf_guid"] = cf_guid + __props__.__dict__["cf_organization_guid"] = cf_organization_guid + __props__.__dict__["cf_space_guid"] = cf_space_guid + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["version"] = version + return LogmeInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the LogMe instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output['outputs.LogmeInstanceParameters']: + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/mariadb_credential.py b/sdk/python/pulumi_stackit/mariadb_credential.py new file mode 100644 index 0000000..bc94396 --- /dev/null +++ b/sdk/python/pulumi_stackit/mariadb_credential.py @@ -0,0 +1,375 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['MariadbCredentialArgs', 'MariadbCredential'] + +@pulumi.input_type +class MariadbCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a MariadbCredential resource. + :param pulumi.Input[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _MariadbCredentialState: + def __init__(__self__, *, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering MariadbCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if host is not None: + pulumi.set(__self__, "host", host) + if hosts is not None: + pulumi.set(__self__, "hosts", hosts) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter + def hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "hosts") + + @hosts.setter + def hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "hosts", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/mariadbCredential:MariadbCredential") +class MariadbCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + MariaDB credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MariadbCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + MariaDB credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param MariadbCredentialArgs 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(MariadbCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = MariadbCredentialArgs.__new__(MariadbCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["credential_id"] = None + __props__.__dict__["host"] = None + __props__.__dict__["hosts"] = None + __props__.__dict__["name"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(MariadbCredential, __self__).__init__( + 'stackit:index/mariadbCredential:MariadbCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'MariadbCredential': + """ + Get an existing MariadbCredential 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[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MariadbCredentialState.__new__(_MariadbCredentialState) + + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["host"] = host + __props__.__dict__["hosts"] = hosts + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["uri"] = uri + __props__.__dict__["username"] = username + return MariadbCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/mariadb_instance.py b/sdk/python/pulumi_stackit/mariadb_instance.py new file mode 100644 index 0000000..5841ee3 --- /dev/null +++ b/sdk/python/pulumi_stackit/mariadb_instance.py @@ -0,0 +1,492 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['MariadbInstanceArgs', 'MariadbInstance'] + +@pulumi.input_type +class MariadbInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['MariadbInstanceParametersArgs']] = None): + """ + The set of arguments for constructing a MariadbInstance resource. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['MariadbInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['MariadbInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _MariadbInstanceState: + def __init__(__self__, *, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['MariadbInstanceParametersArgs']] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering MariadbInstance resources. + :param pulumi.Input[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + if cf_guid is not None: + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid is not None: + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid is not None: + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_guid") + + @cf_guid.setter + def cf_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_guid", value) + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_organization_guid") + + @cf_organization_guid.setter + def cf_organization_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_organization_guid", value) + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_space_guid") + + @cf_space_guid.setter + def cf_space_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_space_guid", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['MariadbInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['MariadbInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/mariadbInstance:MariadbInstance") +class MariadbInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['MariadbInstanceParametersArgs', 'MariadbInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + MariaDB instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MariadbInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + MariaDB instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param MariadbInstanceArgs 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(MariadbInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['MariadbInstanceParametersArgs', 'MariadbInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.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__ = MariadbInstanceArgs.__new__(MariadbInstanceArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["cf_guid"] = None + __props__.__dict__["cf_organization_guid"] = None + __props__.__dict__["cf_space_guid"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["image_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["plan_id"] = None + super(MariadbInstance, __self__).__init__( + 'stackit:index/mariadbInstance:MariadbInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['MariadbInstanceParametersArgs', 'MariadbInstanceParametersArgsDict']]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'MariadbInstance': + """ + Get an existing MariadbInstance 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[builtins.str] instance_id: ID of the MariaDB instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MariadbInstanceState.__new__(_MariadbInstanceState) + + __props__.__dict__["cf_guid"] = cf_guid + __props__.__dict__["cf_organization_guid"] = cf_organization_guid + __props__.__dict__["cf_space_guid"] = cf_space_guid + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["version"] = version + return MariadbInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the MariaDB instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output['outputs.MariadbInstanceParameters']: + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/modelserving_token.py b/sdk/python/pulumi_stackit/modelserving_token.py new file mode 100644 index 0000000..69d038b --- /dev/null +++ b/sdk/python/pulumi_stackit/modelserving_token.py @@ -0,0 +1,510 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ModelservingTokenArgs', 'ModelservingToken'] + +@pulumi.input_type +class ModelservingTokenArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + description: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + ttl_duration: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ModelservingToken resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the AI model serving auth token is associated. + :param pulumi.Input[builtins.str] description: The description of the AI model serving auth token. + :param pulumi.Input[builtins.str] name: Name of the AI model serving auth token. + :param pulumi.Input[builtins.str] region: Region to which the AI model serving auth token is associated. If not defined, the provider region is used + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] ttl_duration: The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + """ + pulumi.set(__self__, "project_id", project_id) + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if ttl_duration is not None: + pulumi.set(__self__, "ttl_duration", ttl_duration) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the AI model serving auth token is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the AI model serving auth token. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the AI model serving auth token. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Region to which the AI model serving auth token is associated. If not defined, the provider region is used + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter(name="ttlDuration") + def ttl_duration(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + """ + return pulumi.get(self, "ttl_duration") + + @ttl_duration.setter + def ttl_duration(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ttl_duration", value) + + +@pulumi.input_type +class _ModelservingTokenState: + def __init__(__self__, *, + description: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + token: Optional[pulumi.Input[builtins.str]] = None, + token_id: Optional[pulumi.Input[builtins.str]] = None, + ttl_duration: Optional[pulumi.Input[builtins.str]] = None, + valid_until: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ModelservingToken resources. + :param pulumi.Input[builtins.str] description: The description of the AI model serving auth token. + :param pulumi.Input[builtins.str] name: Name of the AI model serving auth token. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the AI model serving auth token is associated. + :param pulumi.Input[builtins.str] region: Region to which the AI model serving auth token is associated. If not defined, the provider region is used + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] state: State of the AI model serving auth token. + :param pulumi.Input[builtins.str] token: Content of the AI model serving auth token. + :param pulumi.Input[builtins.str] token_id: The AI model serving auth token ID. + :param pulumi.Input[builtins.str] ttl_duration: The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + :param pulumi.Input[builtins.str] valid_until: The time until the AI model serving auth token is valid. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if state is not None: + pulumi.set(__self__, "state", state) + if token is not None: + pulumi.set(__self__, "token", token) + if token_id is not None: + pulumi.set(__self__, "token_id", token_id) + if ttl_duration is not None: + pulumi.set(__self__, "ttl_duration", ttl_duration) + if valid_until is not None: + pulumi.set(__self__, "valid_until", valid_until) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the AI model serving auth token. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the AI model serving auth token. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the AI model serving auth token is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Region to which the AI model serving auth token is associated. If not defined, the provider region is used + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter + def state(self) -> Optional[pulumi.Input[builtins.str]]: + """ + State of the AI model serving auth token. + """ + return pulumi.get(self, "state") + + @state.setter + def state(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "state", value) + + @property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Content of the AI model serving auth token. + """ + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "token", value) + + @property + @pulumi.getter(name="tokenId") + def token_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The AI model serving auth token ID. + """ + return pulumi.get(self, "token_id") + + @token_id.setter + def token_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "token_id", value) + + @property + @pulumi.getter(name="ttlDuration") + def ttl_duration(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + """ + return pulumi.get(self, "ttl_duration") + + @ttl_duration.setter + def ttl_duration(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ttl_duration", value) + + @property + @pulumi.getter(name="validUntil") + def valid_until(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The time until the AI model serving auth token is valid. + """ + return pulumi.get(self, "valid_until") + + @valid_until.setter + def valid_until(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "valid_until", value) + + +@pulumi.type_token("stackit:index/modelservingToken:ModelservingToken") +class ModelservingToken(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + ttl_duration: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + AI Model Serving Auth Token Resource schema. + + ## Example Usage + + ### Automatically rotate AI model serving token + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] description: The description of the AI model serving auth token. + :param pulumi.Input[builtins.str] name: Name of the AI model serving auth token. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the AI model serving auth token is associated. + :param pulumi.Input[builtins.str] region: Region to which the AI model serving auth token is associated. If not defined, the provider region is used + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] ttl_duration: The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ModelservingTokenArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + AI Model Serving Auth Token Resource schema. + + ## Example Usage + + ### Automatically rotate AI model serving token + + :param str resource_name: The name of the resource. + :param ModelservingTokenArgs 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(ModelservingTokenArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + ttl_duration: Optional[pulumi.Input[builtins.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__ = ModelservingTokenArgs.__new__(ModelservingTokenArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + __props__.__dict__["ttl_duration"] = ttl_duration + __props__.__dict__["state"] = None + __props__.__dict__["token"] = None + __props__.__dict__["token_id"] = None + __props__.__dict__["valid_until"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["token"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ModelservingToken, __self__).__init__( + 'stackit:index/modelservingToken:ModelservingToken', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + state: Optional[pulumi.Input[builtins.str]] = None, + token: Optional[pulumi.Input[builtins.str]] = None, + token_id: Optional[pulumi.Input[builtins.str]] = None, + ttl_duration: Optional[pulumi.Input[builtins.str]] = None, + valid_until: Optional[pulumi.Input[builtins.str]] = None) -> 'ModelservingToken': + """ + Get an existing ModelservingToken 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[builtins.str] description: The description of the AI model serving auth token. + :param pulumi.Input[builtins.str] name: Name of the AI model serving auth token. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the AI model serving auth token is associated. + :param pulumi.Input[builtins.str] region: Region to which the AI model serving auth token is associated. If not defined, the provider region is used + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] state: State of the AI model serving auth token. + :param pulumi.Input[builtins.str] token: Content of the AI model serving auth token. + :param pulumi.Input[builtins.str] token_id: The AI model serving auth token ID. + :param pulumi.Input[builtins.str] ttl_duration: The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + :param pulumi.Input[builtins.str] valid_until: The time until the AI model serving auth token is valid. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ModelservingTokenState.__new__(_ModelservingTokenState) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + __props__.__dict__["state"] = state + __props__.__dict__["token"] = token + __props__.__dict__["token_id"] = token_id + __props__.__dict__["ttl_duration"] = ttl_duration + __props__.__dict__["valid_until"] = valid_until + return ModelservingToken(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The description of the AI model serving auth token. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Name of the AI model serving auth token. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the AI model serving auth token is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + Region to which the AI model serving auth token is associated. If not defined, the provider region is used + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @property + @pulumi.getter + def state(self) -> pulumi.Output[builtins.str]: + """ + State of the AI model serving auth token. + """ + return pulumi.get(self, "state") + + @property + @pulumi.getter + def token(self) -> pulumi.Output[builtins.str]: + """ + Content of the AI model serving auth token. + """ + return pulumi.get(self, "token") + + @property + @pulumi.getter(name="tokenId") + def token_id(self) -> pulumi.Output[builtins.str]: + """ + The AI model serving auth token ID. + """ + return pulumi.get(self, "token_id") + + @property + @pulumi.getter(name="ttlDuration") + def ttl_duration(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The TTL duration of the AI model serving auth token. E.g. 5h30m40s,5h,5h30m,30m,30s + """ + return pulumi.get(self, "ttl_duration") + + @property + @pulumi.getter(name="validUntil") + def valid_until(self) -> pulumi.Output[builtins.str]: + """ + The time until the AI model serving auth token is valid. + """ + return pulumi.get(self, "valid_until") + diff --git a/sdk/python/pulumi_stackit/mongodbflex_instance.py b/sdk/python/pulumi_stackit/mongodbflex_instance.py new file mode 100644 index 0000000..74f7b57 --- /dev/null +++ b/sdk/python/pulumi_stackit/mongodbflex_instance.py @@ -0,0 +1,505 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['MongodbflexInstanceArgs', 'MongodbflexInstance'] + +@pulumi.input_type +class MongodbflexInstanceArgs: + def __init__(__self__, *, + acls: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + backup_schedule: pulumi.Input[builtins.str], + flavor: pulumi.Input['MongodbflexInstanceFlavorArgs'], + options: pulumi.Input['MongodbflexInstanceOptionsArgs'], + project_id: pulumi.Input[builtins.str], + replicas: pulumi.Input[builtins.int], + storage: pulumi.Input['MongodbflexInstanceStorageArgs'], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a MongodbflexInstance resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the MongoDB Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "acls", acls) + pulumi.set(__self__, "backup_schedule", backup_schedule) + pulumi.set(__self__, "flavor", flavor) + pulumi.set(__self__, "options", options) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "replicas", replicas) + pulumi.set(__self__, "storage", storage) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def acls(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + The Access Control List (ACL) for the MongoDB Flex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> pulumi.Input[builtins.str]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + """ + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def flavor(self) -> pulumi.Input['MongodbflexInstanceFlavorArgs']: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: pulumi.Input['MongodbflexInstanceFlavorArgs']): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter + def options(self) -> pulumi.Input['MongodbflexInstanceOptionsArgs']: + return pulumi.get(self, "options") + + @options.setter + def options(self, value: pulumi.Input['MongodbflexInstanceOptionsArgs']): + pulumi.set(self, "options", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def replicas(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "replicas") + + @replicas.setter + def replicas(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "replicas", value) + + @property + @pulumi.getter + def storage(self) -> pulumi.Input['MongodbflexInstanceStorageArgs']: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: pulumi.Input['MongodbflexInstanceStorageArgs']): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _MongodbflexInstanceState: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input['MongodbflexInstanceFlavorArgs']] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input['MongodbflexInstanceOptionsArgs']] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input['MongodbflexInstanceStorageArgs']] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering MongodbflexInstance resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the MongoDB Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + :param pulumi.Input[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if backup_schedule is not None: + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor is not None: + pulumi.set(__self__, "flavor", flavor) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if options is not None: + pulumi.set(__self__, "options", options) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if replicas is not None: + pulumi.set(__self__, "replicas", replicas) + if storage is not None: + pulumi.set(__self__, "storage", storage) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The Access Control List (ACL) for the MongoDB Flex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + """ + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def flavor(self) -> Optional[pulumi.Input['MongodbflexInstanceFlavorArgs']]: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: Optional[pulumi.Input['MongodbflexInstanceFlavorArgs']]): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def options(self) -> Optional[pulumi.Input['MongodbflexInstanceOptionsArgs']]: + return pulumi.get(self, "options") + + @options.setter + def options(self, value: Optional[pulumi.Input['MongodbflexInstanceOptionsArgs']]): + pulumi.set(self, "options", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def replicas(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "replicas") + + @replicas.setter + def replicas(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "replicas", value) + + @property + @pulumi.getter + def storage(self) -> Optional[pulumi.Input['MongodbflexInstanceStorageArgs']]: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: Optional[pulumi.Input['MongodbflexInstanceStorageArgs']]): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/mongodbflexInstance:MongodbflexInstance") +class MongodbflexInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['MongodbflexInstanceFlavorArgs', 'MongodbflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['MongodbflexInstanceOptionsArgs', 'MongodbflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['MongodbflexInstanceStorageArgs', 'MongodbflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the MongoDB Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MongodbflexInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + MongoDB Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param MongodbflexInstanceArgs 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(MongodbflexInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['MongodbflexInstanceFlavorArgs', 'MongodbflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['MongodbflexInstanceOptionsArgs', 'MongodbflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['MongodbflexInstanceStorageArgs', 'MongodbflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.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__ = MongodbflexInstanceArgs.__new__(MongodbflexInstanceArgs) + + if acls is None and not opts.urn: + raise TypeError("Missing required property 'acls'") + __props__.__dict__["acls"] = acls + if backup_schedule is None and not opts.urn: + raise TypeError("Missing required property 'backup_schedule'") + __props__.__dict__["backup_schedule"] = backup_schedule + if flavor is None and not opts.urn: + raise TypeError("Missing required property 'flavor'") + __props__.__dict__["flavor"] = flavor + __props__.__dict__["name"] = name + if options is None and not opts.urn: + raise TypeError("Missing required property 'options'") + __props__.__dict__["options"] = options + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if replicas is None and not opts.urn: + raise TypeError("Missing required property 'replicas'") + __props__.__dict__["replicas"] = replicas + if storage is None and not opts.urn: + raise TypeError("Missing required property 'storage'") + __props__.__dict__["storage"] = storage + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["instance_id"] = None + super(MongodbflexInstance, __self__).__init__( + 'stackit:index/mongodbflexInstance:MongodbflexInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['MongodbflexInstanceFlavorArgs', 'MongodbflexInstanceFlavorArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['MongodbflexInstanceOptionsArgs', 'MongodbflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['MongodbflexInstanceStorageArgs', 'MongodbflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'MongodbflexInstance': + """ + Get an existing MongodbflexInstance 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[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the MongoDB Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + :param pulumi.Input[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MongodbflexInstanceState.__new__(_MongodbflexInstanceState) + + __props__.__dict__["acls"] = acls + __props__.__dict__["backup_schedule"] = backup_schedule + __props__.__dict__["flavor"] = flavor + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["options"] = options + __props__.__dict__["project_id"] = project_id + __props__.__dict__["replicas"] = replicas + __props__.__dict__["storage"] = storage + __props__.__dict__["version"] = version + return MongodbflexInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acls(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The Access Control List (ACL) for the MongoDB Flex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> pulumi.Output[builtins.str]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *"). + """ + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> pulumi.Output['outputs.MongodbflexInstanceFlavor']: + return pulumi.get(self, "flavor") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def options(self) -> pulumi.Output['outputs.MongodbflexInstanceOptions']: + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def replicas(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> pulumi.Output['outputs.MongodbflexInstanceStorage']: + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/mongodbflex_user.py b/sdk/python/pulumi_stackit/mongodbflex_user.py new file mode 100644 index 0000000..396acb6 --- /dev/null +++ b/sdk/python/pulumi_stackit/mongodbflex_user.py @@ -0,0 +1,432 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['MongodbflexUserArgs', 'MongodbflexUser'] + +@pulumi.input_type +class MongodbflexUserArgs: + def __init__(__self__, *, + database: pulumi.Input[builtins.str], + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + roles: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + username: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a MongodbflexUser resource. + :param pulumi.Input[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + """ + pulumi.set(__self__, "database", database) + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "roles", roles) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def database(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "database") + + @database.setter + def database(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "database", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def roles(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.input_type +class _MongodbflexUserState: + def __init__(__self__, *, + database: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering MongodbflexUser resources. + :param pulumi.Input[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + :param pulumi.Input[builtins.str] user_id: User ID. + """ + if database is not None: + pulumi.set(__self__, "database", database) + if host is not None: + pulumi.set(__self__, "host", host) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if roles is not None: + pulumi.set(__self__, "roles", roles) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def database(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "database") + + @database.setter + def database(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "database", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_id", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/mongodbflexUser:MongodbflexUser") +class MongodbflexUser(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + database: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MongodbflexUserArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + MongoDB Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param MongodbflexUserArgs 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(MongodbflexUserArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + database: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.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__ = MongodbflexUserArgs.__new__(MongodbflexUserArgs) + + if database is None and not opts.urn: + raise TypeError("Missing required property 'database'") + __props__.__dict__["database"] = database + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if roles is None and not opts.urn: + raise TypeError("Missing required property 'roles'") + __props__.__dict__["roles"] = roles + __props__.__dict__["username"] = username + __props__.__dict__["host"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["user_id"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(MongodbflexUser, __self__).__init__( + 'stackit:index/mongodbflexUser:MongodbflexUser', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + database: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'MongodbflexUser': + """ + Get an existing MongodbflexUser 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[builtins.str] instance_id: ID of the MongoDB Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + :param pulumi.Input[builtins.str] user_id: User ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MongodbflexUserState.__new__(_MongodbflexUserState) + + __props__.__dict__["database"] = database + __props__.__dict__["host"] = host + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["roles"] = roles + __props__.__dict__["uri"] = uri + __props__.__dict__["user_id"] = user_id + __props__.__dict__["username"] = username + return MongodbflexUser(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def database(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "database") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the MongoDB Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def roles(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + Database access levels for the user. Some of the possible values are: [`read`, `readWrite`, `readWriteAnyDatabase`] + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[builtins.str]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/network.py b/sdk/python/pulumi_stackit/network.py new file mode 100644 index 0000000..4ee492a --- /dev/null +++ b/sdk/python/pulumi_stackit/network.py @@ -0,0 +1,969 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['NetworkArgs', 'Network'] + +@pulumi.input_type +class NetworkArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + ipv4_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv4_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv4_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv6_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv6_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv6_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + no_ipv4_gateway: Optional[pulumi.Input[builtins.bool]] = None, + no_ipv6_gateway: Optional[pulumi.Input[builtins.bool]] = None, + routed: Optional[pulumi.Input[builtins.bool]] = None): + """ + The set of arguments for constructing a Network resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.str] ipv4_gateway: The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_nameservers: The IPv4 nameservers of the network. + :param pulumi.Input[builtins.str] ipv4_prefix: The IPv4 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv4_prefix_length: The IPv4 prefix length of the network. + :param pulumi.Input[builtins.str] ipv6_gateway: The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_nameservers: The IPv6 nameservers of the network. + :param pulumi.Input[builtins.str] ipv6_prefix: The IPv6 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv6_prefix_length: The IPv6 prefix length of the network. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] nameservers: The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + :param pulumi.Input[builtins.bool] no_ipv4_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.bool] no_ipv6_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.bool] routed: If set to `true`, the network is routed and therefore accessible from other networks. + """ + pulumi.set(__self__, "project_id", project_id) + if ipv4_gateway is not None: + pulumi.set(__self__, "ipv4_gateway", ipv4_gateway) + if ipv4_nameservers is not None: + pulumi.set(__self__, "ipv4_nameservers", ipv4_nameservers) + if ipv4_prefix is not None: + pulumi.set(__self__, "ipv4_prefix", ipv4_prefix) + if ipv4_prefix_length is not None: + pulumi.set(__self__, "ipv4_prefix_length", ipv4_prefix_length) + if ipv6_gateway is not None: + pulumi.set(__self__, "ipv6_gateway", ipv6_gateway) + if ipv6_nameservers is not None: + pulumi.set(__self__, "ipv6_nameservers", ipv6_nameservers) + if ipv6_prefix is not None: + pulumi.set(__self__, "ipv6_prefix", ipv6_prefix) + if ipv6_prefix_length is not None: + pulumi.set(__self__, "ipv6_prefix_length", ipv6_prefix_length) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if nameservers is not None: + warnings.warn("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""", DeprecationWarning) + pulumi.log.warn("""nameservers is deprecated: Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + if nameservers is not None: + pulumi.set(__self__, "nameservers", nameservers) + if no_ipv4_gateway is not None: + pulumi.set(__self__, "no_ipv4_gateway", no_ipv4_gateway) + if no_ipv6_gateway is not None: + pulumi.set(__self__, "no_ipv6_gateway", no_ipv6_gateway) + if routed is not None: + pulumi.set(__self__, "routed", routed) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="ipv4Gateway") + def ipv4_gateway(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv4_gateway") + + @ipv4_gateway.setter + def ipv4_gateway(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4_gateway", value) + + @property + @pulumi.getter(name="ipv4Nameservers") + def ipv4_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv4 nameservers of the network. + """ + return pulumi.get(self, "ipv4_nameservers") + + @ipv4_nameservers.setter + def ipv4_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv4_nameservers", value) + + @property + @pulumi.getter(name="ipv4Prefix") + def ipv4_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv4_prefix") + + @ipv4_prefix.setter + def ipv4_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4_prefix", value) + + @property + @pulumi.getter(name="ipv4PrefixLength") + def ipv4_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The IPv4 prefix length of the network. + """ + return pulumi.get(self, "ipv4_prefix_length") + + @ipv4_prefix_length.setter + def ipv4_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ipv4_prefix_length", value) + + @property + @pulumi.getter(name="ipv6Gateway") + def ipv6_gateway(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv6_gateway") + + @ipv6_gateway.setter + def ipv6_gateway(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv6_gateway", value) + + @property + @pulumi.getter(name="ipv6Nameservers") + def ipv6_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv6 nameservers of the network. + """ + return pulumi.get(self, "ipv6_nameservers") + + @ipv6_nameservers.setter + def ipv6_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv6_nameservers", value) + + @property + @pulumi.getter(name="ipv6Prefix") + def ipv6_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv6 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv6_prefix") + + @ipv6_prefix.setter + def ipv6_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv6_prefix", value) + + @property + @pulumi.getter(name="ipv6PrefixLength") + def ipv6_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The IPv6 prefix length of the network. + """ + return pulumi.get(self, "ipv6_prefix_length") + + @ipv6_prefix_length.setter + def ipv6_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ipv6_prefix_length", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + def nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + """ + return pulumi.get(self, "nameservers") + + @nameservers.setter + def nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "nameservers", value) + + @property + @pulumi.getter(name="noIpv4Gateway") + def no_ipv4_gateway(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv4_gateway") + + @no_ipv4_gateway.setter + def no_ipv4_gateway(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "no_ipv4_gateway", value) + + @property + @pulumi.getter(name="noIpv6Gateway") + def no_ipv6_gateway(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv6_gateway") + + @no_ipv6_gateway.setter + def no_ipv6_gateway(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "no_ipv6_gateway", value) + + @property + @pulumi.getter + def routed(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network is routed and therefore accessible from other networks. + """ + return pulumi.get(self, "routed") + + @routed.setter + def routed(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "routed", value) + + +@pulumi.input_type +class _NetworkState: + def __init__(__self__, *, + ipv4_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv4_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv4_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv4_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv6_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv6_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv6_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + no_ipv4_gateway: Optional[pulumi.Input[builtins.bool]] = None, + no_ipv6_gateway: Optional[pulumi.Input[builtins.bool]] = None, + prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip: Optional[pulumi.Input[builtins.str]] = None, + routed: Optional[pulumi.Input[builtins.bool]] = None): + """ + Input properties used for looking up and filtering Network resources. + :param pulumi.Input[builtins.str] ipv4_gateway: The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_nameservers: The IPv4 nameservers of the network. + :param pulumi.Input[builtins.str] ipv4_prefix: The IPv4 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv4_prefix_length: The IPv4 prefix length of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_prefixes: The IPv4 prefixes of the network. + :param pulumi.Input[builtins.str] ipv6_gateway: The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_nameservers: The IPv6 nameservers of the network. + :param pulumi.Input[builtins.str] ipv6_prefix: The IPv6 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv6_prefix_length: The IPv6 prefix length of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_prefixes: The IPv6 prefixes of the network. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] nameservers: The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + :param pulumi.Input[builtins.str] network_id: The network ID. + :param pulumi.Input[builtins.bool] no_ipv4_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.bool] no_ipv6_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] prefixes: The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.str] public_ip: The public IP of the network. + :param pulumi.Input[builtins.bool] routed: If set to `true`, the network is routed and therefore accessible from other networks. + """ + if ipv4_gateway is not None: + pulumi.set(__self__, "ipv4_gateway", ipv4_gateway) + if ipv4_nameservers is not None: + pulumi.set(__self__, "ipv4_nameservers", ipv4_nameservers) + if ipv4_prefix is not None: + pulumi.set(__self__, "ipv4_prefix", ipv4_prefix) + if ipv4_prefix_length is not None: + pulumi.set(__self__, "ipv4_prefix_length", ipv4_prefix_length) + if ipv4_prefixes is not None: + pulumi.set(__self__, "ipv4_prefixes", ipv4_prefixes) + if ipv6_gateway is not None: + pulumi.set(__self__, "ipv6_gateway", ipv6_gateway) + if ipv6_nameservers is not None: + pulumi.set(__self__, "ipv6_nameservers", ipv6_nameservers) + if ipv6_prefix is not None: + pulumi.set(__self__, "ipv6_prefix", ipv6_prefix) + if ipv6_prefix_length is not None: + pulumi.set(__self__, "ipv6_prefix_length", ipv6_prefix_length) + if ipv6_prefixes is not None: + pulumi.set(__self__, "ipv6_prefixes", ipv6_prefixes) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if nameservers is not None: + warnings.warn("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""", DeprecationWarning) + pulumi.log.warn("""nameservers is deprecated: Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + if nameservers is not None: + pulumi.set(__self__, "nameservers", nameservers) + if network_id is not None: + pulumi.set(__self__, "network_id", network_id) + if no_ipv4_gateway is not None: + pulumi.set(__self__, "no_ipv4_gateway", no_ipv4_gateway) + if no_ipv6_gateway is not None: + pulumi.set(__self__, "no_ipv6_gateway", no_ipv6_gateway) + if prefixes is not None: + warnings.warn("""Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.""", DeprecationWarning) + pulumi.log.warn("""prefixes is deprecated: Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.""") + if prefixes is not None: + pulumi.set(__self__, "prefixes", prefixes) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if public_ip is not None: + pulumi.set(__self__, "public_ip", public_ip) + if routed is not None: + pulumi.set(__self__, "routed", routed) + + @property + @pulumi.getter(name="ipv4Gateway") + def ipv4_gateway(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv4_gateway") + + @ipv4_gateway.setter + def ipv4_gateway(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4_gateway", value) + + @property + @pulumi.getter(name="ipv4Nameservers") + def ipv4_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv4 nameservers of the network. + """ + return pulumi.get(self, "ipv4_nameservers") + + @ipv4_nameservers.setter + def ipv4_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv4_nameservers", value) + + @property + @pulumi.getter(name="ipv4Prefix") + def ipv4_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv4_prefix") + + @ipv4_prefix.setter + def ipv4_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4_prefix", value) + + @property + @pulumi.getter(name="ipv4PrefixLength") + def ipv4_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The IPv4 prefix length of the network. + """ + return pulumi.get(self, "ipv4_prefix_length") + + @ipv4_prefix_length.setter + def ipv4_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ipv4_prefix_length", value) + + @property + @pulumi.getter(name="ipv4Prefixes") + def ipv4_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv4 prefixes of the network. + """ + return pulumi.get(self, "ipv4_prefixes") + + @ipv4_prefixes.setter + def ipv4_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv4_prefixes", value) + + @property + @pulumi.getter(name="ipv6Gateway") + def ipv6_gateway(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv6_gateway") + + @ipv6_gateway.setter + def ipv6_gateway(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv6_gateway", value) + + @property + @pulumi.getter(name="ipv6Nameservers") + def ipv6_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv6 nameservers of the network. + """ + return pulumi.get(self, "ipv6_nameservers") + + @ipv6_nameservers.setter + def ipv6_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv6_nameservers", value) + + @property + @pulumi.getter(name="ipv6Prefix") + def ipv6_prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv6 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv6_prefix") + + @ipv6_prefix.setter + def ipv6_prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv6_prefix", value) + + @property + @pulumi.getter(name="ipv6PrefixLength") + def ipv6_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The IPv6 prefix length of the network. + """ + return pulumi.get(self, "ipv6_prefix_length") + + @ipv6_prefix_length.setter + def ipv6_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ipv6_prefix_length", value) + + @property + @pulumi.getter(name="ipv6Prefixes") + def ipv6_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IPv6 prefixes of the network. + """ + return pulumi.get(self, "ipv6_prefixes") + + @ipv6_prefixes.setter + def ipv6_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "ipv6_prefixes", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + def nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + """ + return pulumi.get(self, "nameservers") + + @nameservers.setter + def nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "nameservers", value) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network ID. + """ + return pulumi.get(self, "network_id") + + @network_id.setter + def network_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_id", value) + + @property + @pulumi.getter(name="noIpv4Gateway") + def no_ipv4_gateway(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv4_gateway") + + @no_ipv4_gateway.setter + def no_ipv4_gateway(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "no_ipv4_gateway", value) + + @property + @pulumi.getter(name="noIpv6Gateway") + def no_ipv6_gateway(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv6_gateway") + + @no_ipv6_gateway.setter + def no_ipv6_gateway(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "no_ipv6_gateway", value) + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.""") + def prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + """ + return pulumi.get(self, "prefixes") + + @prefixes.setter + def prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "prefixes", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="publicIp") + def public_ip(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The public IP of the network. + """ + return pulumi.get(self, "public_ip") + + @public_ip.setter + def public_ip(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_ip", value) + + @property + @pulumi.getter + def routed(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to `true`, the network is routed and therefore accessible from other networks. + """ + return pulumi.get(self, "routed") + + @routed.setter + def routed(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "routed", value) + + +@pulumi.type_token("stackit:index/network:Network") +class Network(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + ipv4_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv4_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv4_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv6_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv6_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv6_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + no_ipv4_gateway: Optional[pulumi.Input[builtins.bool]] = None, + no_ipv6_gateway: Optional[pulumi.Input[builtins.bool]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + routed: Optional[pulumi.Input[builtins.bool]] = None, + __props__=None): + """ + Network resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] ipv4_gateway: The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_nameservers: The IPv4 nameservers of the network. + :param pulumi.Input[builtins.str] ipv4_prefix: The IPv4 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv4_prefix_length: The IPv4 prefix length of the network. + :param pulumi.Input[builtins.str] ipv6_gateway: The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_nameservers: The IPv6 nameservers of the network. + :param pulumi.Input[builtins.str] ipv6_prefix: The IPv6 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv6_prefix_length: The IPv6 prefix length of the network. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] nameservers: The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + :param pulumi.Input[builtins.bool] no_ipv4_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.bool] no_ipv6_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.bool] routed: If set to `true`, the network is routed and therefore accessible from other networks. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NetworkArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Network resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param NetworkArgs 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(NetworkArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + ipv4_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv4_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv4_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv6_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv6_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv6_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + no_ipv4_gateway: Optional[pulumi.Input[builtins.bool]] = None, + no_ipv6_gateway: Optional[pulumi.Input[builtins.bool]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + routed: Optional[pulumi.Input[builtins.bool]] = 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__ = NetworkArgs.__new__(NetworkArgs) + + __props__.__dict__["ipv4_gateway"] = ipv4_gateway + __props__.__dict__["ipv4_nameservers"] = ipv4_nameservers + __props__.__dict__["ipv4_prefix"] = ipv4_prefix + __props__.__dict__["ipv4_prefix_length"] = ipv4_prefix_length + __props__.__dict__["ipv6_gateway"] = ipv6_gateway + __props__.__dict__["ipv6_nameservers"] = ipv6_nameservers + __props__.__dict__["ipv6_prefix"] = ipv6_prefix + __props__.__dict__["ipv6_prefix_length"] = ipv6_prefix_length + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["nameservers"] = nameservers + __props__.__dict__["no_ipv4_gateway"] = no_ipv4_gateway + __props__.__dict__["no_ipv6_gateway"] = no_ipv6_gateway + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["routed"] = routed + __props__.__dict__["ipv4_prefixes"] = None + __props__.__dict__["ipv6_prefixes"] = None + __props__.__dict__["network_id"] = None + __props__.__dict__["prefixes"] = None + __props__.__dict__["public_ip"] = None + super(Network, __self__).__init__( + 'stackit:index/network:Network', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + ipv4_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv4_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv4_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv4_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_gateway: Optional[pulumi.Input[builtins.str]] = None, + ipv6_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv6_prefix: Optional[pulumi.Input[builtins.str]] = None, + ipv6_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + ipv6_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + no_ipv4_gateway: Optional[pulumi.Input[builtins.bool]] = None, + no_ipv6_gateway: Optional[pulumi.Input[builtins.bool]] = None, + prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip: Optional[pulumi.Input[builtins.str]] = None, + routed: Optional[pulumi.Input[builtins.bool]] = None) -> 'Network': + """ + Get an existing Network 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[builtins.str] ipv4_gateway: The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_nameservers: The IPv4 nameservers of the network. + :param pulumi.Input[builtins.str] ipv4_prefix: The IPv4 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv4_prefix_length: The IPv4 prefix length of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv4_prefixes: The IPv4 prefixes of the network. + :param pulumi.Input[builtins.str] ipv6_gateway: The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_nameservers: The IPv6 nameservers of the network. + :param pulumi.Input[builtins.str] ipv6_prefix: The IPv6 prefix of the network (CIDR). + :param pulumi.Input[builtins.int] ipv6_prefix_length: The IPv6 prefix length of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ipv6_prefixes: The IPv6 prefixes of the network. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the network. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] nameservers: The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + :param pulumi.Input[builtins.str] network_id: The network ID. + :param pulumi.Input[builtins.bool] no_ipv4_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[builtins.bool] no_ipv6_gateway: If set to `true`, the network doesn't have a gateway. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] prefixes: The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.str] public_ip: The public IP of the network. + :param pulumi.Input[builtins.bool] routed: If set to `true`, the network is routed and therefore accessible from other networks. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NetworkState.__new__(_NetworkState) + + __props__.__dict__["ipv4_gateway"] = ipv4_gateway + __props__.__dict__["ipv4_nameservers"] = ipv4_nameservers + __props__.__dict__["ipv4_prefix"] = ipv4_prefix + __props__.__dict__["ipv4_prefix_length"] = ipv4_prefix_length + __props__.__dict__["ipv4_prefixes"] = ipv4_prefixes + __props__.__dict__["ipv6_gateway"] = ipv6_gateway + __props__.__dict__["ipv6_nameservers"] = ipv6_nameservers + __props__.__dict__["ipv6_prefix"] = ipv6_prefix + __props__.__dict__["ipv6_prefix_length"] = ipv6_prefix_length + __props__.__dict__["ipv6_prefixes"] = ipv6_prefixes + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["nameservers"] = nameservers + __props__.__dict__["network_id"] = network_id + __props__.__dict__["no_ipv4_gateway"] = no_ipv4_gateway + __props__.__dict__["no_ipv6_gateway"] = no_ipv6_gateway + __props__.__dict__["prefixes"] = prefixes + __props__.__dict__["project_id"] = project_id + __props__.__dict__["public_ip"] = public_ip + __props__.__dict__["routed"] = routed + return Network(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="ipv4Gateway") + def ipv4_gateway(self) -> pulumi.Output[builtins.str]: + """ + The IPv4 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv4_gateway") + + @property + @pulumi.getter(name="ipv4Nameservers") + def ipv4_nameservers(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The IPv4 nameservers of the network. + """ + return pulumi.get(self, "ipv4_nameservers") + + @property + @pulumi.getter(name="ipv4Prefix") + def ipv4_prefix(self) -> pulumi.Output[builtins.str]: + """ + The IPv4 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv4_prefix") + + @property + @pulumi.getter(name="ipv4PrefixLength") + def ipv4_prefix_length(self) -> pulumi.Output[builtins.int]: + """ + The IPv4 prefix length of the network. + """ + return pulumi.get(self, "ipv4_prefix_length") + + @property + @pulumi.getter(name="ipv4Prefixes") + def ipv4_prefixes(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The IPv4 prefixes of the network. + """ + return pulumi.get(self, "ipv4_prefixes") + + @property + @pulumi.getter(name="ipv6Gateway") + def ipv6_gateway(self) -> pulumi.Output[builtins.str]: + """ + The IPv6 gateway of a network. If not specified, the first IP of the network will be assigned as the gateway. + """ + return pulumi.get(self, "ipv6_gateway") + + @property + @pulumi.getter(name="ipv6Nameservers") + def ipv6_nameservers(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The IPv6 nameservers of the network. + """ + return pulumi.get(self, "ipv6_nameservers") + + @property + @pulumi.getter(name="ipv6Prefix") + def ipv6_prefix(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The IPv6 prefix of the network (CIDR). + """ + return pulumi.get(self, "ipv6_prefix") + + @property + @pulumi.getter(name="ipv6PrefixLength") + def ipv6_prefix_length(self) -> pulumi.Output[Optional[builtins.int]]: + """ + The IPv6 prefix length of the network. + """ + return pulumi.get(self, "ipv6_prefix_length") + + @property + @pulumi.getter(name="ipv6Prefixes") + def ipv6_prefixes(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The IPv6 prefixes of the network. + """ + return pulumi.get(self, "ipv6_prefixes") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the network. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_nameservers` to configure the nameservers for IPv4.""") + def nameservers(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The nameservers of the network. This field is deprecated and will be removed soon, use `ipv4_nameservers` to configure the nameservers for IPv4. + """ + return pulumi.get(self, "nameservers") + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> pulumi.Output[builtins.str]: + """ + The network ID. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter(name="noIpv4Gateway") + def no_ipv4_gateway(self) -> pulumi.Output[Optional[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv4_gateway") + + @property + @pulumi.getter(name="noIpv6Gateway") + def no_ipv6_gateway(self) -> pulumi.Output[Optional[builtins.bool]]: + """ + If set to `true`, the network doesn't have a gateway. + """ + return pulumi.get(self, "no_ipv6_gateway") + + @property + @pulumi.getter + @_utilities.deprecated("""Use `ipv4_prefixes` to read the prefixes of the IPv4 networks.""") + def prefixes(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The prefixes of the network. This field is deprecated and will be removed soon, use `ipv4_prefixes` to read the prefixes of the IPv4 networks. + """ + return pulumi.get(self, "prefixes") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicIp") + def public_ip(self) -> pulumi.Output[builtins.str]: + """ + The public IP of the network. + """ + return pulumi.get(self, "public_ip") + + @property + @pulumi.getter + def routed(self) -> pulumi.Output[builtins.bool]: + """ + If set to `true`, the network is routed and therefore accessible from other networks. + """ + return pulumi.get(self, "routed") + diff --git a/sdk/python/pulumi_stackit/network_area.py b/sdk/python/pulumi_stackit/network_area.py new file mode 100644 index 0000000..1554d66 --- /dev/null +++ b/sdk/python/pulumi_stackit/network_area.py @@ -0,0 +1,593 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['NetworkAreaArgs', 'NetworkArea'] + +@pulumi.input_type +class NetworkAreaArgs: + def __init__(__self__, *, + network_ranges: pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]], + organization_id: pulumi.Input[builtins.str], + transfer_network: pulumi.Input[builtins.str], + default_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + default_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + min_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a NetworkArea resource. + :param pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]] network_ranges: List of Network ranges. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] transfer_network: Classless Inter-Domain Routing (CIDR). + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] default_nameservers: List of DNS Servers/Nameservers. + :param pulumi.Input[builtins.int] default_prefix_length: The default prefix length for networks in the network area. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.int] max_prefix_length: The maximal prefix length for networks in the network area. + :param pulumi.Input[builtins.int] min_prefix_length: The minimal prefix length for networks in the network area. + :param pulumi.Input[builtins.str] name: The name of the network area. + """ + pulumi.set(__self__, "network_ranges", network_ranges) + pulumi.set(__self__, "organization_id", organization_id) + pulumi.set(__self__, "transfer_network", transfer_network) + if default_nameservers is not None: + pulumi.set(__self__, "default_nameservers", default_nameservers) + if default_prefix_length is not None: + pulumi.set(__self__, "default_prefix_length", default_prefix_length) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if max_prefix_length is not None: + pulumi.set(__self__, "max_prefix_length", max_prefix_length) + if min_prefix_length is not None: + pulumi.set(__self__, "min_prefix_length", min_prefix_length) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="networkRanges") + def network_ranges(self) -> pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]]: + """ + List of Network ranges. + """ + return pulumi.get(self, "network_ranges") + + @network_ranges.setter + def network_ranges(self, value: pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]]): + pulumi.set(self, "network_ranges", value) + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @organization_id.setter + def organization_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "organization_id", value) + + @property + @pulumi.getter(name="transferNetwork") + def transfer_network(self) -> pulumi.Input[builtins.str]: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "transfer_network") + + @transfer_network.setter + def transfer_network(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "transfer_network", value) + + @property + @pulumi.getter(name="defaultNameservers") + def default_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of DNS Servers/Nameservers. + """ + return pulumi.get(self, "default_nameservers") + + @default_nameservers.setter + def default_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "default_nameservers", value) + + @property + @pulumi.getter(name="defaultPrefixLength") + def default_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The default prefix length for networks in the network area. + """ + return pulumi.get(self, "default_prefix_length") + + @default_prefix_length.setter + def default_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "default_prefix_length", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="maxPrefixLength") + def max_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximal prefix length for networks in the network area. + """ + return pulumi.get(self, "max_prefix_length") + + @max_prefix_length.setter + def max_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_prefix_length", value) + + @property + @pulumi.getter(name="minPrefixLength") + def min_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimal prefix length for networks in the network area. + """ + return pulumi.get(self, "min_prefix_length") + + @min_prefix_length.setter + def min_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_prefix_length", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network area. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _NetworkAreaState: + def __init__(__self__, *, + default_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + default_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + min_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + network_ranges: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + project_count: Optional[pulumi.Input[builtins.int]] = None, + transfer_network: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering NetworkArea resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] default_nameservers: List of DNS Servers/Nameservers. + :param pulumi.Input[builtins.int] default_prefix_length: The default prefix length for networks in the network area. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.int] max_prefix_length: The maximal prefix length for networks in the network area. + :param pulumi.Input[builtins.int] min_prefix_length: The minimal prefix length for networks in the network area. + :param pulumi.Input[builtins.str] name: The name of the network area. + :param pulumi.Input[builtins.str] network_area_id: The network area ID. + :param pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]] network_ranges: List of Network ranges. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.int] project_count: The amount of projects currently referencing this area. + :param pulumi.Input[builtins.str] transfer_network: Classless Inter-Domain Routing (CIDR). + """ + if default_nameservers is not None: + pulumi.set(__self__, "default_nameservers", default_nameservers) + if default_prefix_length is not None: + pulumi.set(__self__, "default_prefix_length", default_prefix_length) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if max_prefix_length is not None: + pulumi.set(__self__, "max_prefix_length", max_prefix_length) + if min_prefix_length is not None: + pulumi.set(__self__, "min_prefix_length", min_prefix_length) + if name is not None: + pulumi.set(__self__, "name", name) + if network_area_id is not None: + pulumi.set(__self__, "network_area_id", network_area_id) + if network_ranges is not None: + pulumi.set(__self__, "network_ranges", network_ranges) + if organization_id is not None: + pulumi.set(__self__, "organization_id", organization_id) + if project_count is not None: + pulumi.set(__self__, "project_count", project_count) + if transfer_network is not None: + pulumi.set(__self__, "transfer_network", transfer_network) + + @property + @pulumi.getter(name="defaultNameservers") + def default_nameservers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + List of DNS Servers/Nameservers. + """ + return pulumi.get(self, "default_nameservers") + + @default_nameservers.setter + def default_nameservers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "default_nameservers", value) + + @property + @pulumi.getter(name="defaultPrefixLength") + def default_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The default prefix length for networks in the network area. + """ + return pulumi.get(self, "default_prefix_length") + + @default_prefix_length.setter + def default_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "default_prefix_length", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="maxPrefixLength") + def max_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The maximal prefix length for networks in the network area. + """ + return pulumi.get(self, "max_prefix_length") + + @max_prefix_length.setter + def max_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "max_prefix_length", value) + + @property + @pulumi.getter(name="minPrefixLength") + def min_prefix_length(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The minimal prefix length for networks in the network area. + """ + return pulumi.get(self, "min_prefix_length") + + @min_prefix_length.setter + def min_prefix_length(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "min_prefix_length", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network area. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network area ID. + """ + return pulumi.get(self, "network_area_id") + + @network_area_id.setter + def network_area_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_area_id", value) + + @property + @pulumi.getter(name="networkRanges") + def network_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]]]: + """ + List of Network ranges. + """ + return pulumi.get(self, "network_ranges") + + @network_ranges.setter + def network_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NetworkAreaNetworkRangeArgs']]]]): + pulumi.set(self, "network_ranges", value) + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @organization_id.setter + def organization_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "organization_id", value) + + @property + @pulumi.getter(name="projectCount") + def project_count(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The amount of projects currently referencing this area. + """ + return pulumi.get(self, "project_count") + + @project_count.setter + def project_count(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "project_count", value) + + @property + @pulumi.getter(name="transferNetwork") + def transfer_network(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "transfer_network") + + @transfer_network.setter + def transfer_network(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "transfer_network", value) + + +@pulumi.type_token("stackit:index/networkArea:NetworkArea") +class NetworkArea(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + default_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + default_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + min_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NetworkAreaNetworkRangeArgs', 'NetworkAreaNetworkRangeArgsDict']]]]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + transfer_network: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Network area resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] default_nameservers: List of DNS Servers/Nameservers. + :param pulumi.Input[builtins.int] default_prefix_length: The default prefix length for networks in the network area. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.int] max_prefix_length: The maximal prefix length for networks in the network area. + :param pulumi.Input[builtins.int] min_prefix_length: The minimal prefix length for networks in the network area. + :param pulumi.Input[builtins.str] name: The name of the network area. + :param pulumi.Input[Sequence[pulumi.Input[Union['NetworkAreaNetworkRangeArgs', 'NetworkAreaNetworkRangeArgsDict']]]] network_ranges: List of Network ranges. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] transfer_network: Classless Inter-Domain Routing (CIDR). + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NetworkAreaArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Network area resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param NetworkAreaArgs 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(NetworkAreaArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + default_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + default_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + min_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NetworkAreaNetworkRangeArgs', 'NetworkAreaNetworkRangeArgsDict']]]]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + transfer_network: Optional[pulumi.Input[builtins.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__ = NetworkAreaArgs.__new__(NetworkAreaArgs) + + __props__.__dict__["default_nameservers"] = default_nameservers + __props__.__dict__["default_prefix_length"] = default_prefix_length + __props__.__dict__["labels"] = labels + __props__.__dict__["max_prefix_length"] = max_prefix_length + __props__.__dict__["min_prefix_length"] = min_prefix_length + __props__.__dict__["name"] = name + if network_ranges is None and not opts.urn: + raise TypeError("Missing required property 'network_ranges'") + __props__.__dict__["network_ranges"] = network_ranges + if organization_id is None and not opts.urn: + raise TypeError("Missing required property 'organization_id'") + __props__.__dict__["organization_id"] = organization_id + if transfer_network is None and not opts.urn: + raise TypeError("Missing required property 'transfer_network'") + __props__.__dict__["transfer_network"] = transfer_network + __props__.__dict__["network_area_id"] = None + __props__.__dict__["project_count"] = None + super(NetworkArea, __self__).__init__( + 'stackit:index/networkArea:NetworkArea', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + default_nameservers: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + default_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + max_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + min_prefix_length: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + network_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NetworkAreaNetworkRangeArgs', 'NetworkAreaNetworkRangeArgsDict']]]]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + project_count: Optional[pulumi.Input[builtins.int]] = None, + transfer_network: Optional[pulumi.Input[builtins.str]] = None) -> 'NetworkArea': + """ + Get an existing NetworkArea 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[Sequence[pulumi.Input[builtins.str]]] default_nameservers: List of DNS Servers/Nameservers. + :param pulumi.Input[builtins.int] default_prefix_length: The default prefix length for networks in the network area. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.int] max_prefix_length: The maximal prefix length for networks in the network area. + :param pulumi.Input[builtins.int] min_prefix_length: The minimal prefix length for networks in the network area. + :param pulumi.Input[builtins.str] name: The name of the network area. + :param pulumi.Input[builtins.str] network_area_id: The network area ID. + :param pulumi.Input[Sequence[pulumi.Input[Union['NetworkAreaNetworkRangeArgs', 'NetworkAreaNetworkRangeArgsDict']]]] network_ranges: List of Network ranges. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.int] project_count: The amount of projects currently referencing this area. + :param pulumi.Input[builtins.str] transfer_network: Classless Inter-Domain Routing (CIDR). + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NetworkAreaState.__new__(_NetworkAreaState) + + __props__.__dict__["default_nameservers"] = default_nameservers + __props__.__dict__["default_prefix_length"] = default_prefix_length + __props__.__dict__["labels"] = labels + __props__.__dict__["max_prefix_length"] = max_prefix_length + __props__.__dict__["min_prefix_length"] = min_prefix_length + __props__.__dict__["name"] = name + __props__.__dict__["network_area_id"] = network_area_id + __props__.__dict__["network_ranges"] = network_ranges + __props__.__dict__["organization_id"] = organization_id + __props__.__dict__["project_count"] = project_count + __props__.__dict__["transfer_network"] = transfer_network + return NetworkArea(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="defaultNameservers") + def default_nameservers(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]: + """ + List of DNS Servers/Nameservers. + """ + return pulumi.get(self, "default_nameservers") + + @property + @pulumi.getter(name="defaultPrefixLength") + def default_prefix_length(self) -> pulumi.Output[builtins.int]: + """ + The default prefix length for networks in the network area. + """ + return pulumi.get(self, "default_prefix_length") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="maxPrefixLength") + def max_prefix_length(self) -> pulumi.Output[builtins.int]: + """ + The maximal prefix length for networks in the network area. + """ + return pulumi.get(self, "max_prefix_length") + + @property + @pulumi.getter(name="minPrefixLength") + def min_prefix_length(self) -> pulumi.Output[builtins.int]: + """ + The minimal prefix length for networks in the network area. + """ + return pulumi.get(self, "min_prefix_length") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the network area. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> pulumi.Output[builtins.str]: + """ + The network area ID. + """ + return pulumi.get(self, "network_area_id") + + @property + @pulumi.getter(name="networkRanges") + def network_ranges(self) -> pulumi.Output[Sequence['outputs.NetworkAreaNetworkRange']]: + """ + List of Network ranges. + """ + return pulumi.get(self, "network_ranges") + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @property + @pulumi.getter(name="projectCount") + def project_count(self) -> pulumi.Output[builtins.int]: + """ + The amount of projects currently referencing this area. + """ + return pulumi.get(self, "project_count") + + @property + @pulumi.getter(name="transferNetwork") + def transfer_network(self) -> pulumi.Output[builtins.str]: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "transfer_network") + diff --git a/sdk/python/pulumi_stackit/network_area_route.py b/sdk/python/pulumi_stackit/network_area_route.py new file mode 100644 index 0000000..0672ae6 --- /dev/null +++ b/sdk/python/pulumi_stackit/network_area_route.py @@ -0,0 +1,376 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['NetworkAreaRouteArgs', 'NetworkAreaRoute'] + +@pulumi.input_type +class NetworkAreaRouteArgs: + def __init__(__self__, *, + network_area_id: pulumi.Input[builtins.str], + next_hop: pulumi.Input[builtins.str], + organization_id: pulumi.Input[builtins.str], + prefix: pulumi.Input[builtins.str], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + The set of arguments for constructing a NetworkAreaRoute resource. + :param pulumi.Input[builtins.str] network_area_id: The network area ID to which the network area route is associated. + :param pulumi.Input[builtins.str] next_hop: The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] prefix: The network, that is reachable though the Next Hop. Should use CIDR notation. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + """ + pulumi.set(__self__, "network_area_id", network_area_id) + pulumi.set(__self__, "next_hop", next_hop) + pulumi.set(__self__, "organization_id", organization_id) + pulumi.set(__self__, "prefix", prefix) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> pulumi.Input[builtins.str]: + """ + The network area ID to which the network area route is associated. + """ + return pulumi.get(self, "network_area_id") + + @network_area_id.setter + def network_area_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "network_area_id", value) + + @property + @pulumi.getter(name="nextHop") + def next_hop(self) -> pulumi.Input[builtins.str]: + """ + The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + """ + return pulumi.get(self, "next_hop") + + @next_hop.setter + def next_hop(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "next_hop", value) + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @organization_id.setter + def organization_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "organization_id", value) + + @property + @pulumi.getter + def prefix(self) -> pulumi.Input[builtins.str]: + """ + The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + return pulumi.get(self, "prefix") + + @prefix.setter + def prefix(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "prefix", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + +@pulumi.input_type +class _NetworkAreaRouteState: + def __init__(__self__, *, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + network_area_route_id: Optional[pulumi.Input[builtins.str]] = None, + next_hop: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + prefix: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering NetworkAreaRoute resources. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] network_area_id: The network area ID to which the network area route is associated. + :param pulumi.Input[builtins.str] network_area_route_id: The network area route ID. + :param pulumi.Input[builtins.str] next_hop: The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] prefix: The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + if labels is not None: + pulumi.set(__self__, "labels", labels) + if network_area_id is not None: + pulumi.set(__self__, "network_area_id", network_area_id) + if network_area_route_id is not None: + pulumi.set(__self__, "network_area_route_id", network_area_route_id) + if next_hop is not None: + pulumi.set(__self__, "next_hop", next_hop) + if organization_id is not None: + pulumi.set(__self__, "organization_id", organization_id) + if prefix is not None: + pulumi.set(__self__, "prefix", prefix) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network area ID to which the network area route is associated. + """ + return pulumi.get(self, "network_area_id") + + @network_area_id.setter + def network_area_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_area_id", value) + + @property + @pulumi.getter(name="networkAreaRouteId") + def network_area_route_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network area route ID. + """ + return pulumi.get(self, "network_area_route_id") + + @network_area_route_id.setter + def network_area_route_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_area_route_id", value) + + @property + @pulumi.getter(name="nextHop") + def next_hop(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + """ + return pulumi.get(self, "next_hop") + + @next_hop.setter + def next_hop(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "next_hop", value) + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @organization_id.setter + def organization_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "organization_id", value) + + @property + @pulumi.getter + def prefix(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + return pulumi.get(self, "prefix") + + @prefix.setter + def prefix(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "prefix", value) + + +@pulumi.type_token("stackit:index/networkAreaRoute:NetworkAreaRoute") +class NetworkAreaRoute(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + next_hop: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + prefix: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Network area route resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] network_area_id: The network area ID to which the network area route is associated. + :param pulumi.Input[builtins.str] next_hop: The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] prefix: The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NetworkAreaRouteArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Network area route resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param NetworkAreaRouteArgs 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(NetworkAreaRouteArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + next_hop: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + prefix: Optional[pulumi.Input[builtins.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__ = NetworkAreaRouteArgs.__new__(NetworkAreaRouteArgs) + + __props__.__dict__["labels"] = labels + if network_area_id is None and not opts.urn: + raise TypeError("Missing required property 'network_area_id'") + __props__.__dict__["network_area_id"] = network_area_id + if next_hop is None and not opts.urn: + raise TypeError("Missing required property 'next_hop'") + __props__.__dict__["next_hop"] = next_hop + if organization_id is None and not opts.urn: + raise TypeError("Missing required property 'organization_id'") + __props__.__dict__["organization_id"] = organization_id + if prefix is None and not opts.urn: + raise TypeError("Missing required property 'prefix'") + __props__.__dict__["prefix"] = prefix + __props__.__dict__["network_area_route_id"] = None + super(NetworkAreaRoute, __self__).__init__( + 'stackit:index/networkAreaRoute:NetworkAreaRoute', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_area_id: Optional[pulumi.Input[builtins.str]] = None, + network_area_route_id: Optional[pulumi.Input[builtins.str]] = None, + next_hop: Optional[pulumi.Input[builtins.str]] = None, + organization_id: Optional[pulumi.Input[builtins.str]] = None, + prefix: Optional[pulumi.Input[builtins.str]] = None) -> 'NetworkAreaRoute': + """ + Get an existing NetworkAreaRoute 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[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] network_area_id: The network area ID to which the network area route is associated. + :param pulumi.Input[builtins.str] network_area_route_id: The network area route ID. + :param pulumi.Input[builtins.str] next_hop: The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + :param pulumi.Input[builtins.str] organization_id: STACKIT organization ID to which the network area is associated. + :param pulumi.Input[builtins.str] prefix: The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NetworkAreaRouteState.__new__(_NetworkAreaRouteState) + + __props__.__dict__["labels"] = labels + __props__.__dict__["network_area_id"] = network_area_id + __props__.__dict__["network_area_route_id"] = network_area_route_id + __props__.__dict__["next_hop"] = next_hop + __props__.__dict__["organization_id"] = organization_id + __props__.__dict__["prefix"] = prefix + return NetworkAreaRoute(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="networkAreaId") + def network_area_id(self) -> pulumi.Output[builtins.str]: + """ + The network area ID to which the network area route is associated. + """ + return pulumi.get(self, "network_area_id") + + @property + @pulumi.getter(name="networkAreaRouteId") + def network_area_route_id(self) -> pulumi.Output[builtins.str]: + """ + The network area route ID. + """ + return pulumi.get(self, "network_area_route_id") + + @property + @pulumi.getter(name="nextHop") + def next_hop(self) -> pulumi.Output[builtins.str]: + """ + The IP address of the routing system, that will route the prefix configured. Should be a valid IPv4 address. + """ + return pulumi.get(self, "next_hop") + + @property + @pulumi.getter(name="organizationId") + def organization_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT organization ID to which the network area is associated. + """ + return pulumi.get(self, "organization_id") + + @property + @pulumi.getter + def prefix(self) -> pulumi.Output[builtins.str]: + """ + The network, that is reachable though the Next Hop. Should use CIDR notation. + """ + return pulumi.get(self, "prefix") + diff --git a/sdk/python/pulumi_stackit/network_interface.py b/sdk/python/pulumi_stackit/network_interface.py new file mode 100644 index 0000000..ea0888c --- /dev/null +++ b/sdk/python/pulumi_stackit/network_interface.py @@ -0,0 +1,599 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['NetworkInterfaceArgs', 'NetworkInterface'] + +@pulumi.input_type +class NetworkInterfaceArgs: + def __init__(__self__, *, + network_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + allowed_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + security: Optional[pulumi.Input[builtins.bool]] = None, + security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + """ + The set of arguments for constructing a NetworkInterface resource. + :param pulumi.Input[builtins.str] network_id: The network ID to which the network interface is associated. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_addresses: The list of CIDR (Classless Inter-Domain Routing) notations. + :param pulumi.Input[builtins.str] ipv4: The IPv4 address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a network interface. + :param pulumi.Input[builtins.str] name: The name of the network interface. + :param pulumi.Input[builtins.bool] security: The Network Interface Security. If set to false, then no security groups will apply to this network interface. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + pulumi.set(__self__, "network_id", network_id) + pulumi.set(__self__, "project_id", project_id) + if allowed_addresses is not None: + pulumi.set(__self__, "allowed_addresses", allowed_addresses) + if ipv4 is not None: + pulumi.set(__self__, "ipv4", ipv4) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if security is not None: + pulumi.set(__self__, "security", security) + if security_group_ids is not None: + pulumi.set(__self__, "security_group_ids", security_group_ids) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> pulumi.Input[builtins.str]: + """ + The network ID to which the network interface is associated. + """ + return pulumi.get(self, "network_id") + + @network_id.setter + def network_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "network_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="allowedAddresses") + def allowed_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The list of CIDR (Classless Inter-Domain Routing) notations. + """ + return pulumi.get(self, "allowed_addresses") + + @allowed_addresses.setter + def allowed_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "allowed_addresses", value) + + @property + @pulumi.getter + def ipv4(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 address. + """ + return pulumi.get(self, "ipv4") + + @ipv4.setter + def ipv4(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a network interface. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network interface. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def security(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + The Network Interface Security. If set to false, then no security groups will apply to this network interface. + """ + return pulumi.get(self, "security") + + @security.setter + def security(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "security", value) + + @property + @pulumi.getter(name="securityGroupIds") + def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + return pulumi.get(self, "security_group_ids") + + @security_group_ids.setter + def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "security_group_ids", value) + + +@pulumi.input_type +class _NetworkInterfaceState: + def __init__(__self__, *, + allowed_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + device: Optional[pulumi.Input[builtins.str]] = None, + ipv4: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + mac: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security: Optional[pulumi.Input[builtins.bool]] = None, + security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + type: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering NetworkInterface resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_addresses: The list of CIDR (Classless Inter-Domain Routing) notations. + :param pulumi.Input[builtins.str] device: The device UUID of the network interface. + :param pulumi.Input[builtins.str] ipv4: The IPv4 address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a network interface. + :param pulumi.Input[builtins.str] mac: The MAC address of network interface. + :param pulumi.Input[builtins.str] name: The name of the network interface. + :param pulumi.Input[builtins.str] network_id: The network ID to which the network interface is associated. + :param pulumi.Input[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.bool] security: The Network Interface Security. If set to false, then no security groups will apply to this network interface. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + :param pulumi.Input[builtins.str] type: Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + """ + if allowed_addresses is not None: + pulumi.set(__self__, "allowed_addresses", allowed_addresses) + if device is not None: + pulumi.set(__self__, "device", device) + if ipv4 is not None: + pulumi.set(__self__, "ipv4", ipv4) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if mac is not None: + pulumi.set(__self__, "mac", mac) + if name is not None: + pulumi.set(__self__, "name", name) + if network_id is not None: + pulumi.set(__self__, "network_id", network_id) + if network_interface_id is not None: + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if security is not None: + pulumi.set(__self__, "security", security) + if security_group_ids is not None: + pulumi.set(__self__, "security_group_ids", security_group_ids) + if type is not None: + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter(name="allowedAddresses") + def allowed_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The list of CIDR (Classless Inter-Domain Routing) notations. + """ + return pulumi.get(self, "allowed_addresses") + + @allowed_addresses.setter + def allowed_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "allowed_addresses", value) + + @property + @pulumi.getter + def device(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The device UUID of the network interface. + """ + return pulumi.get(self, "device") + + @device.setter + def device(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "device", value) + + @property + @pulumi.getter + def ipv4(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IPv4 address. + """ + return pulumi.get(self, "ipv4") + + @ipv4.setter + def ipv4(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ipv4", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a network interface. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def mac(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The MAC address of network interface. + """ + return pulumi.get(self, "mac") + + @mac.setter + def mac(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "mac", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the network interface. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network ID to which the network interface is associated. + """ + return pulumi.get(self, "network_id") + + @network_id.setter + def network_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_id", value) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def security(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + The Network Interface Security. If set to false, then no security groups will apply to this network interface. + """ + return pulumi.get(self, "security") + + @security.setter + def security(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "security", value) + + @property + @pulumi.getter(name="securityGroupIds") + def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + return pulumi.get(self, "security_group_ids") + + @security_group_ids.setter + def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "security_group_ids", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + """ + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "type", value) + + +@pulumi.type_token("stackit:index/networkInterface:NetworkInterface") +class NetworkInterface(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + allowed_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security: Optional[pulumi.Input[builtins.bool]] = None, + security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + __props__=None): + """ + Network interface resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_addresses: The list of CIDR (Classless Inter-Domain Routing) notations. + :param pulumi.Input[builtins.str] ipv4: The IPv4 address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a network interface. + :param pulumi.Input[builtins.str] name: The name of the network interface. + :param pulumi.Input[builtins.str] network_id: The network ID to which the network interface is associated. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.bool] security: The Network Interface Security. If set to false, then no security groups will apply to this network interface. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: NetworkInterfaceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Network interface resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param NetworkInterfaceArgs 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(NetworkInterfaceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + allowed_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + ipv4: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security: Optional[pulumi.Input[builtins.bool]] = None, + security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.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__ = NetworkInterfaceArgs.__new__(NetworkInterfaceArgs) + + __props__.__dict__["allowed_addresses"] = allowed_addresses + __props__.__dict__["ipv4"] = ipv4 + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + if network_id is None and not opts.urn: + raise TypeError("Missing required property 'network_id'") + __props__.__dict__["network_id"] = network_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["security"] = security + __props__.__dict__["security_group_ids"] = security_group_ids + __props__.__dict__["device"] = None + __props__.__dict__["mac"] = None + __props__.__dict__["network_interface_id"] = None + __props__.__dict__["type"] = None + super(NetworkInterface, __self__).__init__( + 'stackit:index/networkInterface:NetworkInterface', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + allowed_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + device: Optional[pulumi.Input[builtins.str]] = None, + ipv4: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + mac: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_id: Optional[pulumi.Input[builtins.str]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security: Optional[pulumi.Input[builtins.bool]] = None, + security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + type: Optional[pulumi.Input[builtins.str]] = None) -> 'NetworkInterface': + """ + Get an existing NetworkInterface 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[Sequence[pulumi.Input[builtins.str]]] allowed_addresses: The list of CIDR (Classless Inter-Domain Routing) notations. + :param pulumi.Input[builtins.str] device: The device UUID of the network interface. + :param pulumi.Input[builtins.str] ipv4: The IPv4 address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a network interface. + :param pulumi.Input[builtins.str] mac: The MAC address of network interface. + :param pulumi.Input[builtins.str] name: The name of the network interface. + :param pulumi.Input[builtins.str] network_id: The network ID to which the network interface is associated. + :param pulumi.Input[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network is associated. + :param pulumi.Input[builtins.bool] security: The Network Interface Security. If set to false, then no security groups will apply to this network interface. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] security_group_ids: The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + :param pulumi.Input[builtins.str] type: Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NetworkInterfaceState.__new__(_NetworkInterfaceState) + + __props__.__dict__["allowed_addresses"] = allowed_addresses + __props__.__dict__["device"] = device + __props__.__dict__["ipv4"] = ipv4 + __props__.__dict__["labels"] = labels + __props__.__dict__["mac"] = mac + __props__.__dict__["name"] = name + __props__.__dict__["network_id"] = network_id + __props__.__dict__["network_interface_id"] = network_interface_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["security"] = security + __props__.__dict__["security_group_ids"] = security_group_ids + __props__.__dict__["type"] = type + return NetworkInterface(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="allowedAddresses") + def allowed_addresses(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The list of CIDR (Classless Inter-Domain Routing) notations. + """ + return pulumi.get(self, "allowed_addresses") + + @property + @pulumi.getter + def device(self) -> pulumi.Output[builtins.str]: + """ + The device UUID of the network interface. + """ + return pulumi.get(self, "device") + + @property + @pulumi.getter + def ipv4(self) -> pulumi.Output[builtins.str]: + """ + The IPv4 address. + """ + return pulumi.get(self, "ipv4") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a network interface. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def mac(self) -> pulumi.Output[builtins.str]: + """ + The MAC address of network interface. + """ + return pulumi.get(self, "mac") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the network interface. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> pulumi.Output[builtins.str]: + """ + The network ID to which the network interface is associated. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Output[builtins.str]: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the network is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def security(self) -> pulumi.Output[builtins.bool]: + """ + The Network Interface Security. If set to false, then no security groups will apply to this network interface. + """ + return pulumi.get(self, "security") + + @property + @pulumi.getter(name="securityGroupIds") + def security_group_ids(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The list of security group UUIDs. If security is set to false, setting this field will lead to an error. + """ + return pulumi.get(self, "security_group_ids") + + @property + @pulumi.getter + def type(self) -> pulumi.Output[builtins.str]: + """ + Type of network interface. Some of the possible values are: Supported values are: `server`, `metadata`, `gateway`. + """ + return pulumi.get(self, "type") + diff --git a/sdk/python/pulumi_stackit/objectstorage_bucket.py b/sdk/python/pulumi_stackit/objectstorage_bucket.py new file mode 100644 index 0000000..a980edb --- /dev/null +++ b/sdk/python/pulumi_stackit/objectstorage_bucket.py @@ -0,0 +1,291 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ObjectstorageBucketArgs', 'ObjectstorageBucket'] + +@pulumi.input_type +class ObjectstorageBucketArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObjectstorageBucket resource. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the bucket is associated. + :param pulumi.Input[builtins.str] name: The bucket name. It must be DNS conform. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the bucket is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The bucket name. It must be DNS conform. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _ObjectstorageBucketState: + def __init__(__self__, *, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + url_path_style: Optional[pulumi.Input[builtins.str]] = None, + url_virtual_hosted_style: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ObjectstorageBucket resources. + :param pulumi.Input[builtins.str] name: The bucket name. It must be DNS conform. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the bucket is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if url_path_style is not None: + pulumi.set(__self__, "url_path_style", url_path_style) + if url_virtual_hosted_style is not None: + pulumi.set(__self__, "url_virtual_hosted_style", url_virtual_hosted_style) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The bucket name. It must be DNS conform. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the bucket is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="urlPathStyle") + def url_path_style(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "url_path_style") + + @url_path_style.setter + def url_path_style(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "url_path_style", value) + + @property + @pulumi.getter(name="urlVirtualHostedStyle") + def url_virtual_hosted_style(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "url_virtual_hosted_style") + + @url_virtual_hosted_style.setter + def url_virtual_hosted_style(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "url_virtual_hosted_style", value) + + +@pulumi.type_token("stackit:index/objectstorageBucket:ObjectstorageBucket") +class ObjectstorageBucket(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: The bucket name. It must be DNS conform. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the bucket is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObjectstorageBucketArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ObjectStorage bucket resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObjectstorageBucketArgs 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(ObjectstorageBucketArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.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__ = ObjectstorageBucketArgs.__new__(ObjectstorageBucketArgs) + + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["url_path_style"] = None + __props__.__dict__["url_virtual_hosted_style"] = None + super(ObjectstorageBucket, __self__).__init__( + 'stackit:index/objectstorageBucket:ObjectstorageBucket', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + url_path_style: Optional[pulumi.Input[builtins.str]] = None, + url_virtual_hosted_style: Optional[pulumi.Input[builtins.str]] = None) -> 'ObjectstorageBucket': + """ + Get an existing ObjectstorageBucket 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[builtins.str] name: The bucket name. It must be DNS conform. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the bucket is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObjectstorageBucketState.__new__(_ObjectstorageBucketState) + + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["url_path_style"] = url_path_style + __props__.__dict__["url_virtual_hosted_style"] = url_virtual_hosted_style + return ObjectstorageBucket(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The bucket name. It must be DNS conform. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the bucket is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="urlPathStyle") + def url_path_style(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "url_path_style") + + @property + @pulumi.getter(name="urlVirtualHostedStyle") + def url_virtual_hosted_style(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "url_virtual_hosted_style") + diff --git a/sdk/python/pulumi_stackit/objectstorage_credential.py b/sdk/python/pulumi_stackit/objectstorage_credential.py new file mode 100644 index 0000000..7e9ad50 --- /dev/null +++ b/sdk/python/pulumi_stackit/objectstorage_credential.py @@ -0,0 +1,389 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ObjectstorageCredentialArgs', 'ObjectstorageCredential'] + +@pulumi.input_type +class ObjectstorageCredentialArgs: + def __init__(__self__, *, + credentials_group_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + expiration_timestamp: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObjectstorageCredential resource. + :param pulumi.Input[builtins.str] credentials_group_id: The credential group ID. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the credential group is associated. + :param pulumi.Input[builtins.str] expiration_timestamp: Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "credentials_group_id", credentials_group_id) + pulumi.set(__self__, "project_id", project_id) + if expiration_timestamp is not None: + pulumi.set(__self__, "expiration_timestamp", expiration_timestamp) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> pulumi.Input[builtins.str]: + """ + The credential group ID. + """ + return pulumi.get(self, "credentials_group_id") + + @credentials_group_id.setter + def credentials_group_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "credentials_group_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the credential group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="expirationTimestamp") + def expiration_timestamp(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + """ + return pulumi.get(self, "expiration_timestamp") + + @expiration_timestamp.setter + def expiration_timestamp(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "expiration_timestamp", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _ObjectstorageCredentialState: + def __init__(__self__, *, + access_key: Optional[pulumi.Input[builtins.str]] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + expiration_timestamp: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + secret_access_key: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ObjectstorageCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential ID. + :param pulumi.Input[builtins.str] credentials_group_id: The credential group ID. + :param pulumi.Input[builtins.str] expiration_timestamp: Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the credential group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if access_key is not None: + pulumi.set(__self__, "access_key", access_key) + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if credentials_group_id is not None: + pulumi.set(__self__, "credentials_group_id", credentials_group_id) + if expiration_timestamp is not None: + pulumi.set(__self__, "expiration_timestamp", expiration_timestamp) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if secret_access_key is not None: + pulumi.set(__self__, "secret_access_key", secret_access_key) + + @property + @pulumi.getter(name="accessKey") + def access_key(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "access_key", value) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential group ID. + """ + return pulumi.get(self, "credentials_group_id") + + @credentials_group_id.setter + def credentials_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_group_id", value) + + @property + @pulumi.getter(name="expirationTimestamp") + def expiration_timestamp(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + """ + return pulumi.get(self, "expiration_timestamp") + + @expiration_timestamp.setter + def expiration_timestamp(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "expiration_timestamp", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the credential group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="secretAccessKey") + def secret_access_key(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "secret_access_key") + + @secret_access_key.setter + def secret_access_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "secret_access_key", value) + + +@pulumi.type_token("stackit:index/objectstorageCredential:ObjectstorageCredential") +class ObjectstorageCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + expiration_timestamp: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] credentials_group_id: The credential group ID. + :param pulumi.Input[builtins.str] expiration_timestamp: Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the credential group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObjectstorageCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ObjectStorage credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObjectstorageCredentialArgs 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(ObjectstorageCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + expiration_timestamp: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.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__ = ObjectstorageCredentialArgs.__new__(ObjectstorageCredentialArgs) + + if credentials_group_id is None and not opts.urn: + raise TypeError("Missing required property 'credentials_group_id'") + __props__.__dict__["credentials_group_id"] = credentials_group_id + __props__.__dict__["expiration_timestamp"] = expiration_timestamp + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["access_key"] = None + __props__.__dict__["credential_id"] = None + __props__.__dict__["name"] = None + __props__.__dict__["secret_access_key"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["secretAccessKey"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ObjectstorageCredential, __self__).__init__( + 'stackit:index/objectstorageCredential:ObjectstorageCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + access_key: Optional[pulumi.Input[builtins.str]] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + expiration_timestamp: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + secret_access_key: Optional[pulumi.Input[builtins.str]] = None) -> 'ObjectstorageCredential': + """ + Get an existing ObjectstorageCredential 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[builtins.str] credential_id: The credential ID. + :param pulumi.Input[builtins.str] credentials_group_id: The credential group ID. + :param pulumi.Input[builtins.str] expiration_timestamp: Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the credential group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObjectstorageCredentialState.__new__(_ObjectstorageCredentialState) + + __props__.__dict__["access_key"] = access_key + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["credentials_group_id"] = credentials_group_id + __props__.__dict__["expiration_timestamp"] = expiration_timestamp + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["secret_access_key"] = secret_access_key + return ObjectstorageCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="accessKey") + def access_key(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "access_key") + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> pulumi.Output[builtins.str]: + """ + The credential group ID. + """ + return pulumi.get(self, "credentials_group_id") + + @property + @pulumi.getter(name="expirationTimestamp") + def expiration_timestamp(self) -> pulumi.Output[builtins.str]: + """ + Expiration timestamp, in RFC339 format without fractional seconds. Example: "2025-01-01T00:00:00Z". If not set, the credential never expires. + """ + return pulumi.get(self, "expiration_timestamp") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the credential group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="secretAccessKey") + def secret_access_key(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "secret_access_key") + diff --git a/sdk/python/pulumi_stackit/objectstorage_credentials_group.py b/sdk/python/pulumi_stackit/objectstorage_credentials_group.py new file mode 100644 index 0000000..ef24a75 --- /dev/null +++ b/sdk/python/pulumi_stackit/objectstorage_credentials_group.py @@ -0,0 +1,307 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ObjectstorageCredentialsGroupArgs', 'ObjectstorageCredentialsGroup'] + +@pulumi.input_type +class ObjectstorageCredentialsGroupArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObjectstorageCredentialsGroup resource. + :param pulumi.Input[builtins.str] project_id: Project ID to which the credentials group is associated. + :param pulumi.Input[builtins.str] name: The credentials group's display name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + Project ID to which the credentials group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credentials group's display name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _ObjectstorageCredentialsGroupState: + def __init__(__self__, *, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + urn: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ObjectstorageCredentialsGroup resources. + :param pulumi.Input[builtins.str] credentials_group_id: The credentials group ID + :param pulumi.Input[builtins.str] name: The credentials group's display name. + :param pulumi.Input[builtins.str] project_id: Project ID to which the credentials group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] urn: Credentials group uniform resource name (URN) + """ + if credentials_group_id is not None: + pulumi.set(__self__, "credentials_group_id", credentials_group_id) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if urn is not None: + pulumi.set(__self__, "urn", urn) + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credentials group ID + """ + return pulumi.get(self, "credentials_group_id") + + @credentials_group_id.setter + def credentials_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_group_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credentials group's display name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Project ID to which the credentials group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def urn(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credentials group uniform resource name (URN) + """ + return pulumi.get(self, "urn") + + @urn.setter + def urn(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "urn", value) + + +@pulumi.type_token("stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup") +class ObjectstorageCredentialsGroup(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: The credentials group's display name. + :param pulumi.Input[builtins.str] project_id: Project ID to which the credentials group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObjectstorageCredentialsGroupArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ObjectStorage credentials group resource schema. Must have a `region` specified in the provider configuration. If you are creating `credentialsgroup` and `bucket` resources simultaneously, please include the `depends_on` field so that they are created sequentially. This prevents errors from concurrent calls to the service enablement that is done in the background. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObjectstorageCredentialsGroupArgs 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(ObjectstorageCredentialsGroupArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.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__ = ObjectstorageCredentialsGroupArgs.__new__(ObjectstorageCredentialsGroupArgs) + + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["credentials_group_id"] = None + __props__.__dict__["urn"] = None + super(ObjectstorageCredentialsGroup, __self__).__init__( + 'stackit:index/objectstorageCredentialsGroup:ObjectstorageCredentialsGroup', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credentials_group_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + urn: Optional[pulumi.Input[builtins.str]] = None) -> 'ObjectstorageCredentialsGroup': + """ + Get an existing ObjectstorageCredentialsGroup 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[builtins.str] credentials_group_id: The credentials group ID + :param pulumi.Input[builtins.str] name: The credentials group's display name. + :param pulumi.Input[builtins.str] project_id: Project ID to which the credentials group is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] urn: Credentials group uniform resource name (URN) + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObjectstorageCredentialsGroupState.__new__(_ObjectstorageCredentialsGroupState) + + __props__.__dict__["credentials_group_id"] = credentials_group_id + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["urn"] = urn + return ObjectstorageCredentialsGroup(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialsGroupId") + def credentials_group_id(self) -> pulumi.Output[builtins.str]: + """ + The credentials group ID + """ + return pulumi.get(self, "credentials_group_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The credentials group's display name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + Project ID to which the credentials group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def urn(self) -> pulumi.Output[builtins.str]: + """ + Credentials group uniform resource name (URN) + """ + return pulumi.get(self, "urn") + diff --git a/sdk/python/pulumi_stackit/observability_alertgroup.py b/sdk/python/pulumi_stackit/observability_alertgroup.py new file mode 100644 index 0000000..7d1f0ae --- /dev/null +++ b/sdk/python/pulumi_stackit/observability_alertgroup.py @@ -0,0 +1,349 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ObservabilityAlertgroupArgs', 'ObservabilityAlertgroup'] + +@pulumi.input_type +class ObservabilityAlertgroupArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + rules: pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]], + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObservabilityAlertgroup resource. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the alert group is associated. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]] rules: Rules for the alert group + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the alert group. Is the identifier and must be unique in the group. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "rules", rules) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + Observability instance ID to which the alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the alert group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rules(self) -> pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]]: + """ + Rules for the alert group + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]]): + pulumi.set(self, "rules", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ObservabilityAlertgroupState: + def __init__(__self__, *, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]]] = None): + """ + Input properties used for looking up and filtering ObservabilityAlertgroup resources. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]] rules: Rules for the alert group + """ + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Observability instance ID to which the alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the alert group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]]]: + """ + Rules for the alert group + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityAlertgroupRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +@pulumi.type_token("stackit:index/observabilityAlertgroup:ObservabilityAlertgroup") +class ObservabilityAlertgroup(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityAlertgroupRuleArgs', 'ObservabilityAlertgroupRuleArgsDict']]]]] = None, + __props__=None): + """ + Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityAlertgroupRuleArgs', 'ObservabilityAlertgroupRuleArgsDict']]]] rules: Rules for the alert group + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObservabilityAlertgroupArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Observability alert group resource schema. Used to create alerts based on metrics (Thanos). Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObservabilityAlertgroupArgs 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(ObservabilityAlertgroupArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityAlertgroupRuleArgs', 'ObservabilityAlertgroupRuleArgsDict']]]]] = 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__ = ObservabilityAlertgroupArgs.__new__(ObservabilityAlertgroupArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["interval"] = interval + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if rules is None and not opts.urn: + raise TypeError("Missing required property 'rules'") + __props__.__dict__["rules"] = rules + super(ObservabilityAlertgroup, __self__).__init__( + 'stackit:index/observabilityAlertgroup:ObservabilityAlertgroup', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityAlertgroupRuleArgs', 'ObservabilityAlertgroupRuleArgsDict']]]]] = None) -> 'ObservabilityAlertgroup': + """ + Get an existing ObservabilityAlertgroup 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[builtins.str] instance_id: Observability instance ID to which the alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityAlertgroupRuleArgs', 'ObservabilityAlertgroupRuleArgsDict']]]] rules: Rules for the alert group + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObservabilityAlertgroupState.__new__(_ObservabilityAlertgroupState) + + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["interval"] = interval + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["rules"] = rules + return ObservabilityAlertgroup(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + Observability instance ID to which the alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[builtins.str]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the alert group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def rules(self) -> pulumi.Output[Sequence['outputs.ObservabilityAlertgroupRule']]: + """ + Rules for the alert group + """ + return pulumi.get(self, "rules") + diff --git a/sdk/python/pulumi_stackit/observability_credential.py b/sdk/python/pulumi_stackit/observability_credential.py new file mode 100644 index 0000000..146c40f --- /dev/null +++ b/sdk/python/pulumi_stackit/observability_credential.py @@ -0,0 +1,263 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ObservabilityCredentialArgs', 'ObservabilityCredential'] + +@pulumi.input_type +class ObservabilityCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a ObservabilityCredential resource. + :param pulumi.Input[builtins.str] instance_id: The Observability Instance ID the credential belongs to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the credential is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + The Observability Instance ID the credential belongs to. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the credential is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _ObservabilityCredentialState: + def __init__(__self__, *, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ObservabilityCredential resources. + :param pulumi.Input[builtins.str] instance_id: The Observability Instance ID the credential belongs to. + :param pulumi.Input[builtins.str] password: Credential password + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the credential is associated. + :param pulumi.Input[builtins.str] username: Credential username + """ + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The Observability Instance ID the credential belongs to. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credential password + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the credential is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Credential username + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/observabilityCredential:ObservabilityCredential") +class ObservabilityCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Observability credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: The Observability Instance ID the credential belongs to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the credential is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObservabilityCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Observability credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObservabilityCredentialArgs 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(ObservabilityCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = ObservabilityCredentialArgs.__new__(ObservabilityCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["password"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ObservabilityCredential, __self__).__init__( + 'stackit:index/observabilityCredential:ObservabilityCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'ObservabilityCredential': + """ + Get an existing ObservabilityCredential 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[builtins.str] instance_id: The Observability Instance ID the credential belongs to. + :param pulumi.Input[builtins.str] password: Credential password + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the credential is associated. + :param pulumi.Input[builtins.str] username: Credential username + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObservabilityCredentialState.__new__(_ObservabilityCredentialState) + + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["project_id"] = project_id + __props__.__dict__["username"] = username + return ObservabilityCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + The Observability Instance ID the credential belongs to. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + """ + Credential password + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the credential is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + """ + Credential username + """ + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/observability_instance.py b/sdk/python/pulumi_stackit/observability_instance.py new file mode 100644 index 0000000..966925d --- /dev/null +++ b/sdk/python/pulumi_stackit/observability_instance.py @@ -0,0 +1,1010 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ObservabilityInstanceArgs', 'ObservabilityInstance'] + +@pulumi.input_type +class ObservabilityInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + alert_config: Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']] = None, + metrics_retention_days: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days1h_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days5m_downsampling: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None): + """ + The set of arguments for constructing a ObservabilityInstance resource. + :param pulumi.Input[builtins.str] plan_name: Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + :param pulumi.Input['ObservabilityInstanceAlertConfigArgs'] alert_config: Alert configuration for the instance. + :param pulumi.Input[builtins.int] metrics_retention_days: Specifies for how many days the raw metrics are kept. + :param pulumi.Input[builtins.int] metrics_retention_days1h_downsampling: Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.int] metrics_retention_days5m_downsampling: Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.str] name: The name of the Observability instance. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: Additional parameters. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + if acls is not None: + pulumi.set(__self__, "acls", acls) + if alert_config is not None: + pulumi.set(__self__, "alert_config", alert_config) + if metrics_retention_days is not None: + pulumi.set(__self__, "metrics_retention_days", metrics_retention_days) + if metrics_retention_days1h_downsampling is not None: + pulumi.set(__self__, "metrics_retention_days1h_downsampling", metrics_retention_days1h_downsampling) + if metrics_retention_days5m_downsampling is not None: + pulumi.set(__self__, "metrics_retention_days5m_downsampling", metrics_retention_days5m_downsampling) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="alertConfig") + def alert_config(self) -> Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']]: + """ + Alert configuration for the instance. + """ + return pulumi.get(self, "alert_config") + + @alert_config.setter + def alert_config(self, value: Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']]): + pulumi.set(self, "alert_config", value) + + @property + @pulumi.getter(name="metricsRetentionDays") + def metrics_retention_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the raw metrics are kept. + """ + return pulumi.get(self, "metrics_retention_days") + + @metrics_retention_days.setter + def metrics_retention_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days", value) + + @property + @pulumi.getter(name="metricsRetentionDays1hDownsampling") + def metrics_retention_days1h_downsampling(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days1h_downsampling") + + @metrics_retention_days1h_downsampling.setter + def metrics_retention_days1h_downsampling(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days1h_downsampling", value) + + @property + @pulumi.getter(name="metricsRetentionDays5mDownsampling") + def metrics_retention_days5m_downsampling(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days5m_downsampling") + + @metrics_retention_days5m_downsampling.setter + def metrics_retention_days5m_downsampling(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days5m_downsampling", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the Observability instance. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Additional parameters. + """ + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _ObservabilityInstanceState: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + alert_config: Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']] = None, + alerting_url: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + grafana_initial_admin_password: Optional[pulumi.Input[builtins.str]] = None, + grafana_initial_admin_user: Optional[pulumi.Input[builtins.str]] = None, + grafana_public_read_access: Optional[pulumi.Input[builtins.bool]] = None, + grafana_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + is_updatable: Optional[pulumi.Input[builtins.bool]] = None, + jaeger_traces_url: Optional[pulumi.Input[builtins.str]] = None, + jaeger_ui_url: Optional[pulumi.Input[builtins.str]] = None, + logs_push_url: Optional[pulumi.Input[builtins.str]] = None, + logs_url: Optional[pulumi.Input[builtins.str]] = None, + metrics_push_url: Optional[pulumi.Input[builtins.str]] = None, + metrics_retention_days: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days1h_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days5m_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_url: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + otlp_traces_url: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + targets_url: Optional[pulumi.Input[builtins.str]] = None, + zipkin_spans_url: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ObservabilityInstance resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + :param pulumi.Input['ObservabilityInstanceAlertConfigArgs'] alert_config: Alert configuration for the instance. + :param pulumi.Input[builtins.str] alerting_url: Specifies Alerting URL. + :param pulumi.Input[builtins.str] dashboard_url: Specifies Observability instance dashboard URL. + :param pulumi.Input[builtins.str] grafana_initial_admin_password: Specifies an initial Grafana admin password. + :param pulumi.Input[builtins.str] grafana_initial_admin_user: Specifies an initial Grafana admin username. + :param pulumi.Input[builtins.bool] grafana_public_read_access: If true, anyone can access Grafana dashboards without logging in. + :param pulumi.Input[builtins.str] grafana_url: Specifies Grafana URL. + :param pulumi.Input[builtins.str] instance_id: The Observability instance ID. + :param pulumi.Input[builtins.bool] is_updatable: Specifies if the instance can be updated. + :param pulumi.Input[builtins.str] logs_push_url: Specifies URL for pushing logs. + :param pulumi.Input[builtins.str] logs_url: Specifies Logs URL. + :param pulumi.Input[builtins.str] metrics_push_url: Specifies URL for pushing metrics. + :param pulumi.Input[builtins.int] metrics_retention_days: Specifies for how many days the raw metrics are kept. + :param pulumi.Input[builtins.int] metrics_retention_days1h_downsampling: Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.int] metrics_retention_days5m_downsampling: Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.str] metrics_url: Specifies metrics URL. + :param pulumi.Input[builtins.str] name: The name of the Observability instance. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: Additional parameters. + :param pulumi.Input[builtins.str] plan_id: The Observability plan ID. + :param pulumi.Input[builtins.str] plan_name: Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] targets_url: Specifies Targets URL. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if alert_config is not None: + pulumi.set(__self__, "alert_config", alert_config) + if alerting_url is not None: + pulumi.set(__self__, "alerting_url", alerting_url) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if grafana_initial_admin_password is not None: + pulumi.set(__self__, "grafana_initial_admin_password", grafana_initial_admin_password) + if grafana_initial_admin_user is not None: + pulumi.set(__self__, "grafana_initial_admin_user", grafana_initial_admin_user) + if grafana_public_read_access is not None: + pulumi.set(__self__, "grafana_public_read_access", grafana_public_read_access) + if grafana_url is not None: + pulumi.set(__self__, "grafana_url", grafana_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if is_updatable is not None: + pulumi.set(__self__, "is_updatable", is_updatable) + if jaeger_traces_url is not None: + pulumi.set(__self__, "jaeger_traces_url", jaeger_traces_url) + if jaeger_ui_url is not None: + pulumi.set(__self__, "jaeger_ui_url", jaeger_ui_url) + if logs_push_url is not None: + pulumi.set(__self__, "logs_push_url", logs_push_url) + if logs_url is not None: + pulumi.set(__self__, "logs_url", logs_url) + if metrics_push_url is not None: + pulumi.set(__self__, "metrics_push_url", metrics_push_url) + if metrics_retention_days is not None: + pulumi.set(__self__, "metrics_retention_days", metrics_retention_days) + if metrics_retention_days1h_downsampling is not None: + pulumi.set(__self__, "metrics_retention_days1h_downsampling", metrics_retention_days1h_downsampling) + if metrics_retention_days5m_downsampling is not None: + pulumi.set(__self__, "metrics_retention_days5m_downsampling", metrics_retention_days5m_downsampling) + if metrics_url is not None: + pulumi.set(__self__, "metrics_url", metrics_url) + if name is not None: + pulumi.set(__self__, "name", name) + if otlp_traces_url is not None: + pulumi.set(__self__, "otlp_traces_url", otlp_traces_url) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if targets_url is not None: + pulumi.set(__self__, "targets_url", targets_url) + if zipkin_spans_url is not None: + pulumi.set(__self__, "zipkin_spans_url", zipkin_spans_url) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="alertConfig") + def alert_config(self) -> Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']]: + """ + Alert configuration for the instance. + """ + return pulumi.get(self, "alert_config") + + @alert_config.setter + def alert_config(self, value: Optional[pulumi.Input['ObservabilityInstanceAlertConfigArgs']]): + pulumi.set(self, "alert_config", value) + + @property + @pulumi.getter(name="alertingUrl") + def alerting_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies Alerting URL. + """ + return pulumi.get(self, "alerting_url") + + @alerting_url.setter + def alerting_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "alerting_url", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies Observability instance dashboard URL. + """ + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="grafanaInitialAdminPassword") + def grafana_initial_admin_password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies an initial Grafana admin password. + """ + return pulumi.get(self, "grafana_initial_admin_password") + + @grafana_initial_admin_password.setter + def grafana_initial_admin_password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "grafana_initial_admin_password", value) + + @property + @pulumi.getter(name="grafanaInitialAdminUser") + def grafana_initial_admin_user(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies an initial Grafana admin username. + """ + return pulumi.get(self, "grafana_initial_admin_user") + + @grafana_initial_admin_user.setter + def grafana_initial_admin_user(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "grafana_initial_admin_user", value) + + @property + @pulumi.getter(name="grafanaPublicReadAccess") + def grafana_public_read_access(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If true, anyone can access Grafana dashboards without logging in. + """ + return pulumi.get(self, "grafana_public_read_access") + + @grafana_public_read_access.setter + def grafana_public_read_access(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "grafana_public_read_access", value) + + @property + @pulumi.getter(name="grafanaUrl") + def grafana_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies Grafana URL. + """ + return pulumi.get(self, "grafana_url") + + @grafana_url.setter + def grafana_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "grafana_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The Observability instance ID. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="isUpdatable") + def is_updatable(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Specifies if the instance can be updated. + """ + return pulumi.get(self, "is_updatable") + + @is_updatable.setter + def is_updatable(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "is_updatable", value) + + @property + @pulumi.getter(name="jaegerTracesUrl") + def jaeger_traces_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "jaeger_traces_url") + + @jaeger_traces_url.setter + def jaeger_traces_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "jaeger_traces_url", value) + + @property + @pulumi.getter(name="jaegerUiUrl") + def jaeger_ui_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "jaeger_ui_url") + + @jaeger_ui_url.setter + def jaeger_ui_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "jaeger_ui_url", value) + + @property + @pulumi.getter(name="logsPushUrl") + def logs_push_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies URL for pushing logs. + """ + return pulumi.get(self, "logs_push_url") + + @logs_push_url.setter + def logs_push_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "logs_push_url", value) + + @property + @pulumi.getter(name="logsUrl") + def logs_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies Logs URL. + """ + return pulumi.get(self, "logs_url") + + @logs_url.setter + def logs_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "logs_url", value) + + @property + @pulumi.getter(name="metricsPushUrl") + def metrics_push_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies URL for pushing metrics. + """ + return pulumi.get(self, "metrics_push_url") + + @metrics_push_url.setter + def metrics_push_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_push_url", value) + + @property + @pulumi.getter(name="metricsRetentionDays") + def metrics_retention_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the raw metrics are kept. + """ + return pulumi.get(self, "metrics_retention_days") + + @metrics_retention_days.setter + def metrics_retention_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days", value) + + @property + @pulumi.getter(name="metricsRetentionDays1hDownsampling") + def metrics_retention_days1h_downsampling(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days1h_downsampling") + + @metrics_retention_days1h_downsampling.setter + def metrics_retention_days1h_downsampling(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days1h_downsampling", value) + + @property + @pulumi.getter(name="metricsRetentionDays5mDownsampling") + def metrics_retention_days5m_downsampling(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days5m_downsampling") + + @metrics_retention_days5m_downsampling.setter + def metrics_retention_days5m_downsampling(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "metrics_retention_days5m_downsampling", value) + + @property + @pulumi.getter(name="metricsUrl") + def metrics_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies metrics URL. + """ + return pulumi.get(self, "metrics_url") + + @metrics_url.setter + def metrics_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_url", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the Observability instance. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="otlpTracesUrl") + def otlp_traces_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "otlp_traces_url") + + @otlp_traces_url.setter + def otlp_traces_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "otlp_traces_url", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Additional parameters. + """ + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The Observability plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="targetsUrl") + def targets_url(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies Targets URL. + """ + return pulumi.get(self, "targets_url") + + @targets_url.setter + def targets_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "targets_url", value) + + @property + @pulumi.getter(name="zipkinSpansUrl") + def zipkin_spans_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "zipkin_spans_url") + + @zipkin_spans_url.setter + def zipkin_spans_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "zipkin_spans_url", value) + + +@pulumi.type_token("stackit:index/observabilityInstance:ObservabilityInstance") +class ObservabilityInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + alert_config: Optional[pulumi.Input[Union['ObservabilityInstanceAlertConfigArgs', 'ObservabilityInstanceAlertConfigArgsDict']]] = None, + metrics_retention_days: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days1h_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days5m_downsampling: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Observability instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + :param pulumi.Input[Union['ObservabilityInstanceAlertConfigArgs', 'ObservabilityInstanceAlertConfigArgsDict']] alert_config: Alert configuration for the instance. + :param pulumi.Input[builtins.int] metrics_retention_days: Specifies for how many days the raw metrics are kept. + :param pulumi.Input[builtins.int] metrics_retention_days1h_downsampling: Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.int] metrics_retention_days5m_downsampling: Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.str] name: The name of the Observability instance. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: Additional parameters. + :param pulumi.Input[builtins.str] plan_name: Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObservabilityInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Observability instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObservabilityInstanceArgs 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(ObservabilityInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + alert_config: Optional[pulumi.Input[Union['ObservabilityInstanceAlertConfigArgs', 'ObservabilityInstanceAlertConfigArgsDict']]] = None, + metrics_retention_days: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days1h_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days5m_downsampling: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = ObservabilityInstanceArgs.__new__(ObservabilityInstanceArgs) + + __props__.__dict__["acls"] = acls + __props__.__dict__["alert_config"] = alert_config + __props__.__dict__["metrics_retention_days"] = metrics_retention_days + __props__.__dict__["metrics_retention_days1h_downsampling"] = metrics_retention_days1h_downsampling + __props__.__dict__["metrics_retention_days5m_downsampling"] = metrics_retention_days5m_downsampling + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["alerting_url"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["grafana_initial_admin_password"] = None + __props__.__dict__["grafana_initial_admin_user"] = None + __props__.__dict__["grafana_public_read_access"] = None + __props__.__dict__["grafana_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["is_updatable"] = None + __props__.__dict__["jaeger_traces_url"] = None + __props__.__dict__["jaeger_ui_url"] = None + __props__.__dict__["logs_push_url"] = None + __props__.__dict__["logs_url"] = None + __props__.__dict__["metrics_push_url"] = None + __props__.__dict__["metrics_url"] = None + __props__.__dict__["otlp_traces_url"] = None + __props__.__dict__["plan_id"] = None + __props__.__dict__["targets_url"] = None + __props__.__dict__["zipkin_spans_url"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["grafanaInitialAdminPassword"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ObservabilityInstance, __self__).__init__( + 'stackit:index/observabilityInstance:ObservabilityInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + alert_config: Optional[pulumi.Input[Union['ObservabilityInstanceAlertConfigArgs', 'ObservabilityInstanceAlertConfigArgsDict']]] = None, + alerting_url: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + grafana_initial_admin_password: Optional[pulumi.Input[builtins.str]] = None, + grafana_initial_admin_user: Optional[pulumi.Input[builtins.str]] = None, + grafana_public_read_access: Optional[pulumi.Input[builtins.bool]] = None, + grafana_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + is_updatable: Optional[pulumi.Input[builtins.bool]] = None, + jaeger_traces_url: Optional[pulumi.Input[builtins.str]] = None, + jaeger_ui_url: Optional[pulumi.Input[builtins.str]] = None, + logs_push_url: Optional[pulumi.Input[builtins.str]] = None, + logs_url: Optional[pulumi.Input[builtins.str]] = None, + metrics_push_url: Optional[pulumi.Input[builtins.str]] = None, + metrics_retention_days: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days1h_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_retention_days5m_downsampling: Optional[pulumi.Input[builtins.int]] = None, + metrics_url: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + otlp_traces_url: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + targets_url: Optional[pulumi.Input[builtins.str]] = None, + zipkin_spans_url: Optional[pulumi.Input[builtins.str]] = None) -> 'ObservabilityInstance': + """ + Get an existing ObservabilityInstance 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[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + :param pulumi.Input[Union['ObservabilityInstanceAlertConfigArgs', 'ObservabilityInstanceAlertConfigArgsDict']] alert_config: Alert configuration for the instance. + :param pulumi.Input[builtins.str] alerting_url: Specifies Alerting URL. + :param pulumi.Input[builtins.str] dashboard_url: Specifies Observability instance dashboard URL. + :param pulumi.Input[builtins.str] grafana_initial_admin_password: Specifies an initial Grafana admin password. + :param pulumi.Input[builtins.str] grafana_initial_admin_user: Specifies an initial Grafana admin username. + :param pulumi.Input[builtins.bool] grafana_public_read_access: If true, anyone can access Grafana dashboards without logging in. + :param pulumi.Input[builtins.str] grafana_url: Specifies Grafana URL. + :param pulumi.Input[builtins.str] instance_id: The Observability instance ID. + :param pulumi.Input[builtins.bool] is_updatable: Specifies if the instance can be updated. + :param pulumi.Input[builtins.str] logs_push_url: Specifies URL for pushing logs. + :param pulumi.Input[builtins.str] logs_url: Specifies Logs URL. + :param pulumi.Input[builtins.str] metrics_push_url: Specifies URL for pushing metrics. + :param pulumi.Input[builtins.int] metrics_retention_days: Specifies for how many days the raw metrics are kept. + :param pulumi.Input[builtins.int] metrics_retention_days1h_downsampling: Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.int] metrics_retention_days5m_downsampling: Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + :param pulumi.Input[builtins.str] metrics_url: Specifies metrics URL. + :param pulumi.Input[builtins.str] name: The name of the Observability instance. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] parameters: Additional parameters. + :param pulumi.Input[builtins.str] plan_id: The Observability plan ID. + :param pulumi.Input[builtins.str] plan_name: Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] targets_url: Specifies Targets URL. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObservabilityInstanceState.__new__(_ObservabilityInstanceState) + + __props__.__dict__["acls"] = acls + __props__.__dict__["alert_config"] = alert_config + __props__.__dict__["alerting_url"] = alerting_url + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["grafana_initial_admin_password"] = grafana_initial_admin_password + __props__.__dict__["grafana_initial_admin_user"] = grafana_initial_admin_user + __props__.__dict__["grafana_public_read_access"] = grafana_public_read_access + __props__.__dict__["grafana_url"] = grafana_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["is_updatable"] = is_updatable + __props__.__dict__["jaeger_traces_url"] = jaeger_traces_url + __props__.__dict__["jaeger_ui_url"] = jaeger_ui_url + __props__.__dict__["logs_push_url"] = logs_push_url + __props__.__dict__["logs_url"] = logs_url + __props__.__dict__["metrics_push_url"] = metrics_push_url + __props__.__dict__["metrics_retention_days"] = metrics_retention_days + __props__.__dict__["metrics_retention_days1h_downsampling"] = metrics_retention_days1h_downsampling + __props__.__dict__["metrics_retention_days5m_downsampling"] = metrics_retention_days5m_downsampling + __props__.__dict__["metrics_url"] = metrics_url + __props__.__dict__["name"] = name + __props__.__dict__["otlp_traces_url"] = otlp_traces_url + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["targets_url"] = targets_url + __props__.__dict__["zipkin_spans_url"] = zipkin_spans_url + return ObservabilityInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acls(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]: + """ + The access control list for this instance. Each entry is an IP address range that is permitted to access, in CIDR notation. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="alertConfig") + def alert_config(self) -> pulumi.Output[Optional['outputs.ObservabilityInstanceAlertConfig']]: + """ + Alert configuration for the instance. + """ + return pulumi.get(self, "alert_config") + + @property + @pulumi.getter(name="alertingUrl") + def alerting_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies Alerting URL. + """ + return pulumi.get(self, "alerting_url") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies Observability instance dashboard URL. + """ + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="grafanaInitialAdminPassword") + def grafana_initial_admin_password(self) -> pulumi.Output[builtins.str]: + """ + Specifies an initial Grafana admin password. + """ + return pulumi.get(self, "grafana_initial_admin_password") + + @property + @pulumi.getter(name="grafanaInitialAdminUser") + def grafana_initial_admin_user(self) -> pulumi.Output[builtins.str]: + """ + Specifies an initial Grafana admin username. + """ + return pulumi.get(self, "grafana_initial_admin_user") + + @property + @pulumi.getter(name="grafanaPublicReadAccess") + def grafana_public_read_access(self) -> pulumi.Output[builtins.bool]: + """ + If true, anyone can access Grafana dashboards without logging in. + """ + return pulumi.get(self, "grafana_public_read_access") + + @property + @pulumi.getter(name="grafanaUrl") + def grafana_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies Grafana URL. + """ + return pulumi.get(self, "grafana_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + The Observability instance ID. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="isUpdatable") + def is_updatable(self) -> pulumi.Output[builtins.bool]: + """ + Specifies if the instance can be updated. + """ + return pulumi.get(self, "is_updatable") + + @property + @pulumi.getter(name="jaegerTracesUrl") + def jaeger_traces_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "jaeger_traces_url") + + @property + @pulumi.getter(name="jaegerUiUrl") + def jaeger_ui_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "jaeger_ui_url") + + @property + @pulumi.getter(name="logsPushUrl") + def logs_push_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies URL for pushing logs. + """ + return pulumi.get(self, "logs_push_url") + + @property + @pulumi.getter(name="logsUrl") + def logs_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies Logs URL. + """ + return pulumi.get(self, "logs_url") + + @property + @pulumi.getter(name="metricsPushUrl") + def metrics_push_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies URL for pushing metrics. + """ + return pulumi.get(self, "metrics_push_url") + + @property + @pulumi.getter(name="metricsRetentionDays") + def metrics_retention_days(self) -> pulumi.Output[builtins.int]: + """ + Specifies for how many days the raw metrics are kept. + """ + return pulumi.get(self, "metrics_retention_days") + + @property + @pulumi.getter(name="metricsRetentionDays1hDownsampling") + def metrics_retention_days1h_downsampling(self) -> pulumi.Output[builtins.int]: + """ + Specifies for how many days the 1h downsampled metrics are kept. must be less than the value of the 5m downsampling retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days1h_downsampling") + + @property + @pulumi.getter(name="metricsRetentionDays5mDownsampling") + def metrics_retention_days5m_downsampling(self) -> pulumi.Output[builtins.int]: + """ + Specifies for how many days the 5m downsampled metrics are kept. must be less than the value of the general retention. Default is set to `0` (disabled). + """ + return pulumi.get(self, "metrics_retention_days5m_downsampling") + + @property + @pulumi.getter(name="metricsUrl") + def metrics_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies metrics URL. + """ + return pulumi.get(self, "metrics_url") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the Observability instance. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="otlpTracesUrl") + def otlp_traces_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "otlp_traces_url") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output[Mapping[str, builtins.str]]: + """ + Additional parameters. + """ + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The Observability plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + Specifies the Observability plan. E.g. `Observability-Monitoring-Medium-EU01`. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="targetsUrl") + def targets_url(self) -> pulumi.Output[builtins.str]: + """ + Specifies Targets URL. + """ + return pulumi.get(self, "targets_url") + + @property + @pulumi.getter(name="zipkinSpansUrl") + def zipkin_spans_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "zipkin_spans_url") + diff --git a/sdk/python/pulumi_stackit/observability_logalertgroup.py b/sdk/python/pulumi_stackit/observability_logalertgroup.py new file mode 100644 index 0000000..59f6d97 --- /dev/null +++ b/sdk/python/pulumi_stackit/observability_logalertgroup.py @@ -0,0 +1,349 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ObservabilityLogalertgroupArgs', 'ObservabilityLogalertgroup'] + +@pulumi.input_type +class ObservabilityLogalertgroupArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + rules: pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]], + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObservabilityLogalertgroup resource. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the log alert group is associated. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the log alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]] rules: Rules for the log alert group + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the log alert group. Is the identifier and must be unique in the group. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "rules", rules) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + Observability instance ID to which the log alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the log alert group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rules(self) -> pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]]: + """ + Rules for the log alert group + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]]): + pulumi.set(self, "rules", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the log alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ObservabilityLogalertgroupState: + def __init__(__self__, *, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]]] = None): + """ + Input properties used for looking up and filtering ObservabilityLogalertgroup resources. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the log alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the log alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the log alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]] rules: Rules for the log alert group + """ + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Observability instance ID to which the log alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the log alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the log alert group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]]]: + """ + Rules for the log alert group + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityLogalertgroupRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +@pulumi.type_token("stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup") +class ObservabilityLogalertgroup(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityLogalertgroupRuleArgs', 'ObservabilityLogalertgroupRuleArgsDict']]]]] = None, + __props__=None): + """ + Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the log alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the log alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the log alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityLogalertgroupRuleArgs', 'ObservabilityLogalertgroupRuleArgsDict']]]] rules: Rules for the log alert group + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObservabilityLogalertgroupArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Observability log alert group resource schema. Used to create alerts based on logs (Loki). Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObservabilityLogalertgroupArgs 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(ObservabilityLogalertgroupArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityLogalertgroupRuleArgs', 'ObservabilityLogalertgroupRuleArgsDict']]]]] = 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__ = ObservabilityLogalertgroupArgs.__new__(ObservabilityLogalertgroupArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["interval"] = interval + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if rules is None and not opts.urn: + raise TypeError("Missing required property 'rules'") + __props__.__dict__["rules"] = rules + super(ObservabilityLogalertgroup, __self__).__init__( + 'stackit:index/observabilityLogalertgroup:ObservabilityLogalertgroup', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + interval: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityLogalertgroupRuleArgs', 'ObservabilityLogalertgroupRuleArgsDict']]]]] = None) -> 'ObservabilityLogalertgroup': + """ + Get an existing ObservabilityLogalertgroup 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[builtins.str] instance_id: Observability instance ID to which the log alert group is associated. + :param pulumi.Input[builtins.str] interval: Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + :param pulumi.Input[builtins.str] name: The name of the log alert group. Is the identifier and must be unique in the group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the log alert group is associated. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityLogalertgroupRuleArgs', 'ObservabilityLogalertgroupRuleArgsDict']]]] rules: Rules for the log alert group + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObservabilityLogalertgroupState.__new__(_ObservabilityLogalertgroupState) + + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["interval"] = interval + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["rules"] = rules + return ObservabilityLogalertgroup(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + Observability instance ID to which the log alert group is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[builtins.str]: + """ + Specifies the frequency at which rules within the group are evaluated. The interval must be at least 60 seconds and defaults to 60 seconds if not set. Supported formats include hours, minutes, and seconds, either singly or in combination. Examples of valid formats are: '5h30m40s', '5h', '5h30m', '60m', and '60s'. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the log alert group. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the log alert group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def rules(self) -> pulumi.Output[Sequence['outputs.ObservabilityLogalertgroupRule']]: + """ + Rules for the log alert group + """ + return pulumi.get(self, "rules") + diff --git a/sdk/python/pulumi_stackit/observability_scrapeconfig.py b/sdk/python/pulumi_stackit/observability_scrapeconfig.py new file mode 100644 index 0000000..8b5bbf7 --- /dev/null +++ b/sdk/python/pulumi_stackit/observability_scrapeconfig.py @@ -0,0 +1,632 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ObservabilityScrapeconfigArgs', 'ObservabilityScrapeconfig'] + +@pulumi.input_type +class ObservabilityScrapeconfigArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + metrics_path: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + targets: pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]], + basic_auth: Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + saml2: Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']] = None, + sample_limit: Optional[pulumi.Input[builtins.int]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + scrape_interval: Optional[pulumi.Input[builtins.str]] = None, + scrape_timeout: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ObservabilityScrapeconfig resource. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the scraping job is associated. + :param pulumi.Input[builtins.str] metrics_path: Specifies the job scraping url path. E.g. `/metrics`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the scraping job is associated. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]] targets: The targets list (specified by the static config). + :param pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs'] basic_auth: A basic authentication block. + :param pulumi.Input[builtins.str] name: Specifies the name of the scraping job. + :param pulumi.Input['ObservabilityScrapeconfigSaml2Args'] saml2: A SAML2 configuration block. + :param pulumi.Input[builtins.int] sample_limit: Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + :param pulumi.Input[builtins.str] scheme: Specifies the http scheme. Defaults to `https`. + :param pulumi.Input[builtins.str] scrape_interval: Specifies the scrape interval as duration string. Defaults to `5m`. + :param pulumi.Input[builtins.str] scrape_timeout: Specifies the scrape timeout as duration string. Defaults to `2m`. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "metrics_path", metrics_path) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "targets", targets) + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if name is not None: + pulumi.set(__self__, "name", name) + if saml2 is not None: + pulumi.set(__self__, "saml2", saml2) + if sample_limit is not None: + pulumi.set(__self__, "sample_limit", sample_limit) + if scheme is not None: + pulumi.set(__self__, "scheme", scheme) + if scrape_interval is not None: + pulumi.set(__self__, "scrape_interval", scrape_interval) + if scrape_timeout is not None: + pulumi.set(__self__, "scrape_timeout", scrape_timeout) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + Observability instance ID to which the scraping job is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="metricsPath") + def metrics_path(self) -> pulumi.Input[builtins.str]: + """ + Specifies the job scraping url path. E.g. `/metrics`. + """ + return pulumi.get(self, "metrics_path") + + @metrics_path.setter + def metrics_path(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "metrics_path", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the scraping job is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def targets(self) -> pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]]: + """ + The targets list (specified by the static config). + """ + return pulumi.get(self, "targets") + + @targets.setter + def targets(self, value: pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]]): + pulumi.set(self, "targets", value) + + @property + @pulumi.getter(name="basicAuth") + def basic_auth(self) -> Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']]: + """ + A basic authentication block. + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']]): + pulumi.set(self, "basic_auth", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the name of the scraping job. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def saml2(self) -> Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']]: + """ + A SAML2 configuration block. + """ + return pulumi.get(self, "saml2") + + @saml2.setter + def saml2(self, value: Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']]): + pulumi.set(self, "saml2", value) + + @property + @pulumi.getter(name="sampleLimit") + def sample_limit(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + """ + return pulumi.get(self, "sample_limit") + + @sample_limit.setter + def sample_limit(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "sample_limit", value) + + @property + @pulumi.getter + def scheme(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the http scheme. Defaults to `https`. + """ + return pulumi.get(self, "scheme") + + @scheme.setter + def scheme(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scheme", value) + + @property + @pulumi.getter(name="scrapeInterval") + def scrape_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the scrape interval as duration string. Defaults to `5m`. + """ + return pulumi.get(self, "scrape_interval") + + @scrape_interval.setter + def scrape_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scrape_interval", value) + + @property + @pulumi.getter(name="scrapeTimeout") + def scrape_timeout(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the scrape timeout as duration string. Defaults to `2m`. + """ + return pulumi.get(self, "scrape_timeout") + + @scrape_timeout.setter + def scrape_timeout(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scrape_timeout", value) + + +@pulumi.input_type +class _ObservabilityScrapeconfigState: + def __init__(__self__, *, + basic_auth: Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + metrics_path: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + saml2: Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']] = None, + sample_limit: Optional[pulumi.Input[builtins.int]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + scrape_interval: Optional[pulumi.Input[builtins.str]] = None, + scrape_timeout: Optional[pulumi.Input[builtins.str]] = None, + targets: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]]] = None): + """ + Input properties used for looking up and filtering ObservabilityScrapeconfig resources. + :param pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs'] basic_auth: A basic authentication block. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the scraping job is associated. + :param pulumi.Input[builtins.str] metrics_path: Specifies the job scraping url path. E.g. `/metrics`. + :param pulumi.Input[builtins.str] name: Specifies the name of the scraping job. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the scraping job is associated. + :param pulumi.Input['ObservabilityScrapeconfigSaml2Args'] saml2: A SAML2 configuration block. + :param pulumi.Input[builtins.int] sample_limit: Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + :param pulumi.Input[builtins.str] scheme: Specifies the http scheme. Defaults to `https`. + :param pulumi.Input[builtins.str] scrape_interval: Specifies the scrape interval as duration string. Defaults to `5m`. + :param pulumi.Input[builtins.str] scrape_timeout: Specifies the scrape timeout as duration string. Defaults to `2m`. + :param pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]] targets: The targets list (specified by the static config). + """ + if basic_auth is not None: + pulumi.set(__self__, "basic_auth", basic_auth) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if metrics_path is not None: + pulumi.set(__self__, "metrics_path", metrics_path) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if saml2 is not None: + pulumi.set(__self__, "saml2", saml2) + if sample_limit is not None: + pulumi.set(__self__, "sample_limit", sample_limit) + if scheme is not None: + pulumi.set(__self__, "scheme", scheme) + if scrape_interval is not None: + pulumi.set(__self__, "scrape_interval", scrape_interval) + if scrape_timeout is not None: + pulumi.set(__self__, "scrape_timeout", scrape_timeout) + if targets is not None: + pulumi.set(__self__, "targets", targets) + + @property + @pulumi.getter(name="basicAuth") + def basic_auth(self) -> Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']]: + """ + A basic authentication block. + """ + return pulumi.get(self, "basic_auth") + + @basic_auth.setter + def basic_auth(self, value: Optional[pulumi.Input['ObservabilityScrapeconfigBasicAuthArgs']]): + pulumi.set(self, "basic_auth", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Observability instance ID to which the scraping job is associated. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="metricsPath") + def metrics_path(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the job scraping url path. E.g. `/metrics`. + """ + return pulumi.get(self, "metrics_path") + + @metrics_path.setter + def metrics_path(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "metrics_path", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the name of the scraping job. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the scraping job is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def saml2(self) -> Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']]: + """ + A SAML2 configuration block. + """ + return pulumi.get(self, "saml2") + + @saml2.setter + def saml2(self, value: Optional[pulumi.Input['ObservabilityScrapeconfigSaml2Args']]): + pulumi.set(self, "saml2", value) + + @property + @pulumi.getter(name="sampleLimit") + def sample_limit(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + """ + return pulumi.get(self, "sample_limit") + + @sample_limit.setter + def sample_limit(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "sample_limit", value) + + @property + @pulumi.getter + def scheme(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the http scheme. Defaults to `https`. + """ + return pulumi.get(self, "scheme") + + @scheme.setter + def scheme(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scheme", value) + + @property + @pulumi.getter(name="scrapeInterval") + def scrape_interval(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the scrape interval as duration string. Defaults to `5m`. + """ + return pulumi.get(self, "scrape_interval") + + @scrape_interval.setter + def scrape_interval(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scrape_interval", value) + + @property + @pulumi.getter(name="scrapeTimeout") + def scrape_timeout(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the scrape timeout as duration string. Defaults to `2m`. + """ + return pulumi.get(self, "scrape_timeout") + + @scrape_timeout.setter + def scrape_timeout(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scrape_timeout", value) + + @property + @pulumi.getter + def targets(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]]]: + """ + The targets list (specified by the static config). + """ + return pulumi.get(self, "targets") + + @targets.setter + def targets(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ObservabilityScrapeconfigTargetArgs']]]]): + pulumi.set(self, "targets", value) + + +@pulumi.type_token("stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig") +class ObservabilityScrapeconfig(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth: Optional[pulumi.Input[Union['ObservabilityScrapeconfigBasicAuthArgs', 'ObservabilityScrapeconfigBasicAuthArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + metrics_path: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + saml2: Optional[pulumi.Input[Union['ObservabilityScrapeconfigSaml2Args', 'ObservabilityScrapeconfigSaml2ArgsDict']]] = None, + sample_limit: Optional[pulumi.Input[builtins.int]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + scrape_interval: Optional[pulumi.Input[builtins.str]] = None, + scrape_timeout: Optional[pulumi.Input[builtins.str]] = None, + targets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityScrapeconfigTargetArgs', 'ObservabilityScrapeconfigTargetArgsDict']]]]] = None, + __props__=None): + """ + Observability scrape config resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ObservabilityScrapeconfigBasicAuthArgs', 'ObservabilityScrapeconfigBasicAuthArgsDict']] basic_auth: A basic authentication block. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the scraping job is associated. + :param pulumi.Input[builtins.str] metrics_path: Specifies the job scraping url path. E.g. `/metrics`. + :param pulumi.Input[builtins.str] name: Specifies the name of the scraping job. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the scraping job is associated. + :param pulumi.Input[Union['ObservabilityScrapeconfigSaml2Args', 'ObservabilityScrapeconfigSaml2ArgsDict']] saml2: A SAML2 configuration block. + :param pulumi.Input[builtins.int] sample_limit: Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + :param pulumi.Input[builtins.str] scheme: Specifies the http scheme. Defaults to `https`. + :param pulumi.Input[builtins.str] scrape_interval: Specifies the scrape interval as duration string. Defaults to `5m`. + :param pulumi.Input[builtins.str] scrape_timeout: Specifies the scrape timeout as duration string. Defaults to `2m`. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityScrapeconfigTargetArgs', 'ObservabilityScrapeconfigTargetArgsDict']]]] targets: The targets list (specified by the static config). + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ObservabilityScrapeconfigArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Observability scrape config resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ObservabilityScrapeconfigArgs 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(ObservabilityScrapeconfigArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth: Optional[pulumi.Input[Union['ObservabilityScrapeconfigBasicAuthArgs', 'ObservabilityScrapeconfigBasicAuthArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + metrics_path: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + saml2: Optional[pulumi.Input[Union['ObservabilityScrapeconfigSaml2Args', 'ObservabilityScrapeconfigSaml2ArgsDict']]] = None, + sample_limit: Optional[pulumi.Input[builtins.int]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + scrape_interval: Optional[pulumi.Input[builtins.str]] = None, + scrape_timeout: Optional[pulumi.Input[builtins.str]] = None, + targets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityScrapeconfigTargetArgs', 'ObservabilityScrapeconfigTargetArgsDict']]]]] = 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__ = ObservabilityScrapeconfigArgs.__new__(ObservabilityScrapeconfigArgs) + + __props__.__dict__["basic_auth"] = basic_auth + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if metrics_path is None and not opts.urn: + raise TypeError("Missing required property 'metrics_path'") + __props__.__dict__["metrics_path"] = metrics_path + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["saml2"] = saml2 + __props__.__dict__["sample_limit"] = sample_limit + __props__.__dict__["scheme"] = scheme + __props__.__dict__["scrape_interval"] = scrape_interval + __props__.__dict__["scrape_timeout"] = scrape_timeout + if targets is None and not opts.urn: + raise TypeError("Missing required property 'targets'") + __props__.__dict__["targets"] = targets + super(ObservabilityScrapeconfig, __self__).__init__( + 'stackit:index/observabilityScrapeconfig:ObservabilityScrapeconfig', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth: Optional[pulumi.Input[Union['ObservabilityScrapeconfigBasicAuthArgs', 'ObservabilityScrapeconfigBasicAuthArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + metrics_path: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + saml2: Optional[pulumi.Input[Union['ObservabilityScrapeconfigSaml2Args', 'ObservabilityScrapeconfigSaml2ArgsDict']]] = None, + sample_limit: Optional[pulumi.Input[builtins.int]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + scrape_interval: Optional[pulumi.Input[builtins.str]] = None, + scrape_timeout: Optional[pulumi.Input[builtins.str]] = None, + targets: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityScrapeconfigTargetArgs', 'ObservabilityScrapeconfigTargetArgsDict']]]]] = None) -> 'ObservabilityScrapeconfig': + """ + Get an existing ObservabilityScrapeconfig 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[Union['ObservabilityScrapeconfigBasicAuthArgs', 'ObservabilityScrapeconfigBasicAuthArgsDict']] basic_auth: A basic authentication block. + :param pulumi.Input[builtins.str] instance_id: Observability instance ID to which the scraping job is associated. + :param pulumi.Input[builtins.str] metrics_path: Specifies the job scraping url path. E.g. `/metrics`. + :param pulumi.Input[builtins.str] name: Specifies the name of the scraping job. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the scraping job is associated. + :param pulumi.Input[Union['ObservabilityScrapeconfigSaml2Args', 'ObservabilityScrapeconfigSaml2ArgsDict']] saml2: A SAML2 configuration block. + :param pulumi.Input[builtins.int] sample_limit: Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + :param pulumi.Input[builtins.str] scheme: Specifies the http scheme. Defaults to `https`. + :param pulumi.Input[builtins.str] scrape_interval: Specifies the scrape interval as duration string. Defaults to `5m`. + :param pulumi.Input[builtins.str] scrape_timeout: Specifies the scrape timeout as duration string. Defaults to `2m`. + :param pulumi.Input[Sequence[pulumi.Input[Union['ObservabilityScrapeconfigTargetArgs', 'ObservabilityScrapeconfigTargetArgsDict']]]] targets: The targets list (specified by the static config). + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ObservabilityScrapeconfigState.__new__(_ObservabilityScrapeconfigState) + + __props__.__dict__["basic_auth"] = basic_auth + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["metrics_path"] = metrics_path + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["saml2"] = saml2 + __props__.__dict__["sample_limit"] = sample_limit + __props__.__dict__["scheme"] = scheme + __props__.__dict__["scrape_interval"] = scrape_interval + __props__.__dict__["scrape_timeout"] = scrape_timeout + __props__.__dict__["targets"] = targets + return ObservabilityScrapeconfig(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="basicAuth") + def basic_auth(self) -> pulumi.Output['outputs.ObservabilityScrapeconfigBasicAuth']: + """ + A basic authentication block. + """ + return pulumi.get(self, "basic_auth") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + Observability instance ID to which the scraping job is associated. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="metricsPath") + def metrics_path(self) -> pulumi.Output[builtins.str]: + """ + Specifies the job scraping url path. E.g. `/metrics`. + """ + return pulumi.get(self, "metrics_path") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Specifies the name of the scraping job. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the scraping job is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def saml2(self) -> pulumi.Output['outputs.ObservabilityScrapeconfigSaml2']: + """ + A SAML2 configuration block. + """ + return pulumi.get(self, "saml2") + + @property + @pulumi.getter(name="sampleLimit") + def sample_limit(self) -> pulumi.Output[builtins.int]: + """ + Specifies the scrape sample limit. Upper limit depends on the service plan. Defaults to `5000`. + """ + return pulumi.get(self, "sample_limit") + + @property + @pulumi.getter + def scheme(self) -> pulumi.Output[builtins.str]: + """ + Specifies the http scheme. Defaults to `https`. + """ + return pulumi.get(self, "scheme") + + @property + @pulumi.getter(name="scrapeInterval") + def scrape_interval(self) -> pulumi.Output[builtins.str]: + """ + Specifies the scrape interval as duration string. Defaults to `5m`. + """ + return pulumi.get(self, "scrape_interval") + + @property + @pulumi.getter(name="scrapeTimeout") + def scrape_timeout(self) -> pulumi.Output[builtins.str]: + """ + Specifies the scrape timeout as duration string. Defaults to `2m`. + """ + return pulumi.get(self, "scrape_timeout") + + @property + @pulumi.getter + def targets(self) -> pulumi.Output[Sequence['outputs.ObservabilityScrapeconfigTarget']]: + """ + The targets list (specified by the static config). + """ + return pulumi.get(self, "targets") + diff --git a/sdk/python/pulumi_stackit/opensearch_credential.py b/sdk/python/pulumi_stackit/opensearch_credential.py new file mode 100644 index 0000000..12a7edc --- /dev/null +++ b/sdk/python/pulumi_stackit/opensearch_credential.py @@ -0,0 +1,375 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['OpensearchCredentialArgs', 'OpensearchCredential'] + +@pulumi.input_type +class OpensearchCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a OpensearchCredential resource. + :param pulumi.Input[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _OpensearchCredentialState: + def __init__(__self__, *, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering OpensearchCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if host is not None: + pulumi.set(__self__, "host", host) + if hosts is not None: + pulumi.set(__self__, "hosts", hosts) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if scheme is not None: + pulumi.set(__self__, "scheme", scheme) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter + def hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "hosts") + + @hosts.setter + def hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "hosts", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def scheme(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "scheme") + + @scheme.setter + def scheme(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "scheme", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/opensearchCredential:OpensearchCredential") +class OpensearchCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + OpenSearch credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: OpensearchCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + OpenSearch credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param OpensearchCredentialArgs 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(OpensearchCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = OpensearchCredentialArgs.__new__(OpensearchCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["credential_id"] = None + __props__.__dict__["host"] = None + __props__.__dict__["hosts"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["scheme"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(OpensearchCredential, __self__).__init__( + 'stackit:index/opensearchCredential:OpensearchCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + scheme: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'OpensearchCredential': + """ + Get an existing OpensearchCredential 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[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _OpensearchCredentialState.__new__(_OpensearchCredentialState) + + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["host"] = host + __props__.__dict__["hosts"] = hosts + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["scheme"] = scheme + __props__.__dict__["uri"] = uri + __props__.__dict__["username"] = username + return OpensearchCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def scheme(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "scheme") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/opensearch_instance.py b/sdk/python/pulumi_stackit/opensearch_instance.py new file mode 100644 index 0000000..8dbdfc0 --- /dev/null +++ b/sdk/python/pulumi_stackit/opensearch_instance.py @@ -0,0 +1,492 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['OpensearchInstanceArgs', 'OpensearchInstance'] + +@pulumi.input_type +class OpensearchInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['OpensearchInstanceParametersArgs']] = None): + """ + The set of arguments for constructing a OpensearchInstance resource. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['OpensearchInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['OpensearchInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _OpensearchInstanceState: + def __init__(__self__, *, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['OpensearchInstanceParametersArgs']] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering OpensearchInstance resources. + :param pulumi.Input[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + if cf_guid is not None: + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid is not None: + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid is not None: + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_guid") + + @cf_guid.setter + def cf_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_guid", value) + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_organization_guid") + + @cf_organization_guid.setter + def cf_organization_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_organization_guid", value) + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_space_guid") + + @cf_space_guid.setter + def cf_space_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_space_guid", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['OpensearchInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['OpensearchInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/opensearchInstance:OpensearchInstance") +class OpensearchInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['OpensearchInstanceParametersArgs', 'OpensearchInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + OpenSearch instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: OpensearchInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + OpenSearch instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param OpensearchInstanceArgs 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(OpensearchInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['OpensearchInstanceParametersArgs', 'OpensearchInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.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__ = OpensearchInstanceArgs.__new__(OpensearchInstanceArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["cf_guid"] = None + __props__.__dict__["cf_organization_guid"] = None + __props__.__dict__["cf_space_guid"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["image_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["plan_id"] = None + super(OpensearchInstance, __self__).__init__( + 'stackit:index/opensearchInstance:OpensearchInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['OpensearchInstanceParametersArgs', 'OpensearchInstanceParametersArgsDict']]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'OpensearchInstance': + """ + Get an existing OpensearchInstance 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[builtins.str] instance_id: ID of the OpenSearch instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _OpensearchInstanceState.__new__(_OpensearchInstanceState) + + __props__.__dict__["cf_guid"] = cf_guid + __props__.__dict__["cf_organization_guid"] = cf_organization_guid + __props__.__dict__["cf_space_guid"] = cf_space_guid + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["version"] = version + return OpensearchInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the OpenSearch instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output['outputs.OpensearchInstanceParameters']: + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/outputs.py b/sdk/python/pulumi_stackit/outputs.py new file mode 100644 index 0000000..7b70e18 --- /dev/null +++ b/sdk/python/pulumi_stackit/outputs.py @@ -0,0 +1,7816 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'CdnDistributionConfig', + 'CdnDistributionConfigBackend', + 'CdnDistributionDomain', + 'ImageChecksum', + 'ImageConfig', + 'LoadbalancerListener', + 'LoadbalancerListenerServerNameIndicator', + 'LoadbalancerNetwork', + 'LoadbalancerOptions', + 'LoadbalancerOptionsObservability', + 'LoadbalancerOptionsObservabilityLogs', + 'LoadbalancerOptionsObservabilityMetrics', + 'LoadbalancerTargetPool', + 'LoadbalancerTargetPoolActiveHealthCheck', + 'LoadbalancerTargetPoolSessionPersistence', + 'LoadbalancerTargetPoolTarget', + 'LogmeInstanceParameters', + 'MariadbInstanceParameters', + 'MongodbflexInstanceFlavor', + 'MongodbflexInstanceOptions', + 'MongodbflexInstanceStorage', + 'NetworkAreaNetworkRange', + 'ObservabilityAlertgroupRule', + 'ObservabilityInstanceAlertConfig', + 'ObservabilityInstanceAlertConfigGlobal', + 'ObservabilityInstanceAlertConfigReceiver', + 'ObservabilityInstanceAlertConfigReceiverEmailConfig', + 'ObservabilityInstanceAlertConfigReceiverOpsgenieConfig', + 'ObservabilityInstanceAlertConfigReceiverWebhooksConfig', + 'ObservabilityInstanceAlertConfigRoute', + 'ObservabilityInstanceAlertConfigRouteRoute', + 'ObservabilityLogalertgroupRule', + 'ObservabilityScrapeconfigBasicAuth', + 'ObservabilityScrapeconfigSaml2', + 'ObservabilityScrapeconfigTarget', + 'OpensearchInstanceParameters', + 'PostgresflexInstanceFlavor', + 'PostgresflexInstanceStorage', + 'RabbitmqInstanceParameters', + 'RedisInstanceParameters', + 'SecurityGroupRuleIcmpParameters', + 'SecurityGroupRulePortRange', + 'SecurityGroupRuleProtocol', + 'ServerBackupScheduleBackupProperties', + 'ServerBootVolume', + 'SkeClusterExtensions', + 'SkeClusterExtensionsAcl', + 'SkeClusterExtensionsArgus', + 'SkeClusterExtensionsDns', + 'SkeClusterHibernation', + 'SkeClusterMaintenance', + 'SkeClusterNetwork', + 'SkeClusterNodePool', + 'SkeClusterNodePoolTaint', + 'SqlserverflexInstanceFlavor', + 'SqlserverflexInstanceOptions', + 'SqlserverflexInstanceStorage', + 'VolumeSource', + 'GetCdnDistributionConfigResult', + 'GetCdnDistributionConfigBackendResult', + 'GetCdnDistributionDomainResult', + 'GetImageChecksumResult', + 'GetImageConfigResult', + 'GetLoadbalancerListenerResult', + 'GetLoadbalancerListenerServerNameIndicatorResult', + 'GetLoadbalancerNetworkResult', + 'GetLoadbalancerOptionsResult', + 'GetLoadbalancerOptionsObservabilityResult', + 'GetLoadbalancerOptionsObservabilityLogsResult', + 'GetLoadbalancerOptionsObservabilityMetricsResult', + 'GetLoadbalancerTargetPoolResult', + 'GetLoadbalancerTargetPoolActiveHealthCheckResult', + 'GetLoadbalancerTargetPoolSessionPersistenceResult', + 'GetLoadbalancerTargetPoolTargetResult', + 'GetLogmeInstanceParametersResult', + 'GetMariadbInstanceParametersResult', + 'GetMongodbflexInstanceFlavorResult', + 'GetMongodbflexInstanceOptionsResult', + 'GetMongodbflexInstanceStorageResult', + 'GetNetworkAreaNetworkRangeResult', + 'GetObservabilityAlertgroupRuleResult', + 'GetObservabilityInstanceAlertConfigResult', + 'GetObservabilityInstanceAlertConfigGlobalResult', + 'GetObservabilityInstanceAlertConfigReceiverResult', + 'GetObservabilityInstanceAlertConfigReceiverEmailConfigResult', + 'GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult', + 'GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult', + 'GetObservabilityInstanceAlertConfigRouteResult', + 'GetObservabilityInstanceAlertConfigRouteRouteResult', + 'GetObservabilityLogalertgroupRuleResult', + 'GetObservabilityScrapeconfigBasicAuthResult', + 'GetObservabilityScrapeconfigSaml2Result', + 'GetObservabilityScrapeconfigTargetResult', + 'GetOpensearchInstanceParametersResult', + 'GetPostgresflexInstanceFlavorResult', + 'GetPostgresflexInstanceStorageResult', + 'GetPublicIpRangesPublicIpRangeResult', + 'GetRabbitmqInstanceParametersResult', + 'GetRedisInstanceParametersResult', + 'GetSecurityGroupRuleIcmpParametersResult', + 'GetSecurityGroupRulePortRangeResult', + 'GetSecurityGroupRuleProtocolResult', + 'GetServerBackupScheduleBackupPropertiesResult', + 'GetServerBackupSchedulesItemResult', + 'GetServerBackupSchedulesItemBackupPropertiesResult', + 'GetServerBootVolumeResult', + 'GetServerUpdateSchedulesItemResult', + 'GetSkeClusterExtensionsResult', + 'GetSkeClusterExtensionsAclResult', + 'GetSkeClusterExtensionsArgusResult', + 'GetSkeClusterExtensionsDnsResult', + 'GetSkeClusterHibernationResult', + 'GetSkeClusterMaintenanceResult', + 'GetSkeClusterNetworkResult', + 'GetSkeClusterNodePoolResult', + 'GetSkeClusterNodePoolTaintResult', + 'GetSqlserverflexInstanceFlavorResult', + 'GetSqlserverflexInstanceOptionsResult', + 'GetSqlserverflexInstanceStorageResult', + 'GetVolumeSourceResult', +] + +@pulumi.output_type +class CdnDistributionConfig(dict): + def __init__(__self__, *, + backend: 'outputs.CdnDistributionConfigBackend', + regions: Sequence[builtins.str]): + """ + :param 'CdnDistributionConfigBackendArgs' backend: The configured backend for the distribution + :param Sequence[builtins.str] regions: The configured regions where content will be hosted + """ + pulumi.set(__self__, "backend", backend) + pulumi.set(__self__, "regions", regions) + + @property + @pulumi.getter + def backend(self) -> 'outputs.CdnDistributionConfigBackend': + """ + The configured backend for the distribution + """ + return pulumi.get(self, "backend") + + @property + @pulumi.getter + def regions(self) -> Sequence[builtins.str]: + """ + The configured regions where content will be hosted + """ + return pulumi.get(self, "regions") + + +@pulumi.output_type +class CdnDistributionConfigBackend(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "originUrl": + suggest = "origin_url" + elif key == "originRequestHeaders": + suggest = "origin_request_headers" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in CdnDistributionConfigBackend. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + CdnDistributionConfigBackend.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + CdnDistributionConfigBackend.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + origin_url: builtins.str, + type: builtins.str, + origin_request_headers: Optional[Mapping[str, builtins.str]] = None): + """ + :param builtins.str origin_url: The configured backend type for the distribution + :param builtins.str type: The configured backend type. Supported values are: `http`. + :param Mapping[str, builtins.str] origin_request_headers: The configured origin request headers for the backend + """ + pulumi.set(__self__, "origin_url", origin_url) + pulumi.set(__self__, "type", type) + if origin_request_headers is not None: + pulumi.set(__self__, "origin_request_headers", origin_request_headers) + + @property + @pulumi.getter(name="originUrl") + def origin_url(self) -> builtins.str: + """ + The configured backend type for the distribution + """ + return pulumi.get(self, "origin_url") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The configured backend type. Supported values are: `http`. + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="originRequestHeaders") + def origin_request_headers(self) -> Optional[Mapping[str, builtins.str]]: + """ + The configured origin request headers for the backend + """ + return pulumi.get(self, "origin_request_headers") + + +@pulumi.output_type +class CdnDistributionDomain(dict): + def __init__(__self__, *, + errors: Optional[Sequence[builtins.str]] = None, + name: Optional[builtins.str] = None, + status: Optional[builtins.str] = None, + type: Optional[builtins.str] = None): + """ + :param Sequence[builtins.str] errors: List of domain errors + :param builtins.str name: The name of the domain + :param builtins.str status: The status of the domain + :param builtins.str type: The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + if errors is not None: + pulumi.set(__self__, "errors", errors) + if name is not None: + pulumi.set(__self__, "name", name) + if status is not None: + pulumi.set(__self__, "status", status) + if type is not None: + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def errors(self) -> Optional[Sequence[builtins.str]]: + """ + List of domain errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter + def name(self) -> Optional[builtins.str]: + """ + The name of the domain + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def status(self) -> Optional[builtins.str]: + """ + The status of the domain + """ + return pulumi.get(self, "status") + + @property + @pulumi.getter + def type(self) -> Optional[builtins.str]: + """ + The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class ImageChecksum(dict): + def __init__(__self__, *, + algorithm: Optional[builtins.str] = None, + digest: Optional[builtins.str] = None): + """ + :param builtins.str algorithm: Algorithm for the checksum of the image data. + :param builtins.str digest: Hexdigest of the checksum of the image data. + """ + if algorithm is not None: + pulumi.set(__self__, "algorithm", algorithm) + if digest is not None: + pulumi.set(__self__, "digest", digest) + + @property + @pulumi.getter + def algorithm(self) -> Optional[builtins.str]: + """ + Algorithm for the checksum of the image data. + """ + return pulumi.get(self, "algorithm") + + @property + @pulumi.getter + def digest(self) -> Optional[builtins.str]: + """ + Hexdigest of the checksum of the image data. + """ + return pulumi.get(self, "digest") + + +@pulumi.output_type +class ImageConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "bootMenu": + suggest = "boot_menu" + elif key == "cdromBus": + suggest = "cdrom_bus" + elif key == "diskBus": + suggest = "disk_bus" + elif key == "nicModel": + suggest = "nic_model" + elif key == "operatingSystem": + suggest = "operating_system" + elif key == "operatingSystemDistro": + suggest = "operating_system_distro" + elif key == "operatingSystemVersion": + suggest = "operating_system_version" + elif key == "rescueBus": + suggest = "rescue_bus" + elif key == "rescueDevice": + suggest = "rescue_device" + elif key == "secureBoot": + suggest = "secure_boot" + elif key == "videoModel": + suggest = "video_model" + elif key == "virtioScsi": + suggest = "virtio_scsi" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ImageConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ImageConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ImageConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + boot_menu: Optional[builtins.bool] = None, + cdrom_bus: Optional[builtins.str] = None, + disk_bus: Optional[builtins.str] = None, + nic_model: Optional[builtins.str] = None, + operating_system: Optional[builtins.str] = None, + operating_system_distro: Optional[builtins.str] = None, + operating_system_version: Optional[builtins.str] = None, + rescue_bus: Optional[builtins.str] = None, + rescue_device: Optional[builtins.str] = None, + secure_boot: Optional[builtins.bool] = None, + uefi: Optional[builtins.bool] = None, + video_model: Optional[builtins.str] = None, + virtio_scsi: Optional[builtins.bool] = None): + """ + :param builtins.bool boot_menu: Enables the BIOS bootmenu. + :param builtins.str cdrom_bus: Sets CDROM bus controller type. + :param builtins.str disk_bus: Sets Disk bus controller type. + :param builtins.str nic_model: Sets virtual network interface model. + :param builtins.str operating_system: Enables operating system specific optimizations. + :param builtins.str operating_system_distro: Operating system distribution. + :param builtins.str operating_system_version: Version of the operating system. + :param builtins.str rescue_bus: Sets the device bus when the image is used as a rescue image. + :param builtins.str rescue_device: Sets the device when the image is used as a rescue image. + :param builtins.bool secure_boot: Enables Secure Boot. + :param builtins.bool uefi: Enables UEFI boot. + :param builtins.str video_model: Sets Graphic device model. + :param builtins.bool virtio_scsi: Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + if boot_menu is not None: + pulumi.set(__self__, "boot_menu", boot_menu) + if cdrom_bus is not None: + pulumi.set(__self__, "cdrom_bus", cdrom_bus) + if disk_bus is not None: + pulumi.set(__self__, "disk_bus", disk_bus) + if nic_model is not None: + pulumi.set(__self__, "nic_model", nic_model) + if operating_system is not None: + pulumi.set(__self__, "operating_system", operating_system) + if operating_system_distro is not None: + pulumi.set(__self__, "operating_system_distro", operating_system_distro) + if operating_system_version is not None: + pulumi.set(__self__, "operating_system_version", operating_system_version) + if rescue_bus is not None: + pulumi.set(__self__, "rescue_bus", rescue_bus) + if rescue_device is not None: + pulumi.set(__self__, "rescue_device", rescue_device) + if secure_boot is not None: + pulumi.set(__self__, "secure_boot", secure_boot) + if uefi is not None: + pulumi.set(__self__, "uefi", uefi) + if video_model is not None: + pulumi.set(__self__, "video_model", video_model) + if virtio_scsi is not None: + pulumi.set(__self__, "virtio_scsi", virtio_scsi) + + @property + @pulumi.getter(name="bootMenu") + def boot_menu(self) -> Optional[builtins.bool]: + """ + Enables the BIOS bootmenu. + """ + return pulumi.get(self, "boot_menu") + + @property + @pulumi.getter(name="cdromBus") + def cdrom_bus(self) -> Optional[builtins.str]: + """ + Sets CDROM bus controller type. + """ + return pulumi.get(self, "cdrom_bus") + + @property + @pulumi.getter(name="diskBus") + def disk_bus(self) -> Optional[builtins.str]: + """ + Sets Disk bus controller type. + """ + return pulumi.get(self, "disk_bus") + + @property + @pulumi.getter(name="nicModel") + def nic_model(self) -> Optional[builtins.str]: + """ + Sets virtual network interface model. + """ + return pulumi.get(self, "nic_model") + + @property + @pulumi.getter(name="operatingSystem") + def operating_system(self) -> Optional[builtins.str]: + """ + Enables operating system specific optimizations. + """ + return pulumi.get(self, "operating_system") + + @property + @pulumi.getter(name="operatingSystemDistro") + def operating_system_distro(self) -> Optional[builtins.str]: + """ + Operating system distribution. + """ + return pulumi.get(self, "operating_system_distro") + + @property + @pulumi.getter(name="operatingSystemVersion") + def operating_system_version(self) -> Optional[builtins.str]: + """ + Version of the operating system. + """ + return pulumi.get(self, "operating_system_version") + + @property + @pulumi.getter(name="rescueBus") + def rescue_bus(self) -> Optional[builtins.str]: + """ + Sets the device bus when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_bus") + + @property + @pulumi.getter(name="rescueDevice") + def rescue_device(self) -> Optional[builtins.str]: + """ + Sets the device when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_device") + + @property + @pulumi.getter(name="secureBoot") + def secure_boot(self) -> Optional[builtins.bool]: + """ + Enables Secure Boot. + """ + return pulumi.get(self, "secure_boot") + + @property + @pulumi.getter + def uefi(self) -> Optional[builtins.bool]: + """ + Enables UEFI boot. + """ + return pulumi.get(self, "uefi") + + @property + @pulumi.getter(name="videoModel") + def video_model(self) -> Optional[builtins.str]: + """ + Sets Graphic device model. + """ + return pulumi.get(self, "video_model") + + @property + @pulumi.getter(name="virtioScsi") + def virtio_scsi(self) -> Optional[builtins.bool]: + """ + Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + return pulumi.get(self, "virtio_scsi") + + +@pulumi.output_type +class LoadbalancerListener(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "targetPool": + suggest = "target_pool" + elif key == "displayName": + suggest = "display_name" + elif key == "serverNameIndicators": + suggest = "server_name_indicators" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerListener. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerListener.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerListener.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + port: builtins.int, + protocol: builtins.str, + target_pool: builtins.str, + display_name: Optional[builtins.str] = None, + server_name_indicators: Optional[Sequence['outputs.LoadbalancerListenerServerNameIndicator']] = None): + """ + :param builtins.int port: Port number where we listen for traffic. + :param builtins.str protocol: Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + :param builtins.str target_pool: Reference target pool by target pool name. + :param Sequence['LoadbalancerListenerServerNameIndicatorArgs'] server_name_indicators: A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "protocol", protocol) + pulumi.set(__self__, "target_pool", target_pool) + if display_name is not None: + pulumi.set(__self__, "display_name", display_name) + if server_name_indicators is not None: + pulumi.set(__self__, "server_name_indicators", server_name_indicators) + + @property + @pulumi.getter + def port(self) -> builtins.int: + """ + Port number where we listen for traffic. + """ + return pulumi.get(self, "port") + + @property + @pulumi.getter + def protocol(self) -> builtins.str: + """ + Protocol is the highest network protocol we understand to load balance. Supported values are: `PROTOCOL_UNSPECIFIED`, `PROTOCOL_TCP`, `PROTOCOL_UDP`, `PROTOCOL_TCP_PROXY`, `PROTOCOL_TLS_PASSTHROUGH`. + """ + return pulumi.get(self, "protocol") + + @property + @pulumi.getter(name="targetPool") + def target_pool(self) -> builtins.str: + """ + Reference target pool by target pool name. + """ + return pulumi.get(self, "target_pool") + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> Optional[builtins.str]: + return pulumi.get(self, "display_name") + + @property + @pulumi.getter(name="serverNameIndicators") + def server_name_indicators(self) -> Optional[Sequence['outputs.LoadbalancerListenerServerNameIndicator']]: + """ + A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "server_name_indicators") + + +@pulumi.output_type +class LoadbalancerListenerServerNameIndicator(dict): + def __init__(__self__, *, + name: Optional[builtins.str] = None): + """ + :param builtins.str name: A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def name(self) -> Optional[builtins.str]: + """ + A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class LoadbalancerNetwork(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "networkId": + suggest = "network_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerNetwork. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerNetwork.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerNetwork.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + network_id: builtins.str, + role: builtins.str): + """ + :param builtins.str network_id: Openstack network ID. + :param builtins.str role: The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + """ + pulumi.set(__self__, "network_id", network_id) + pulumi.set(__self__, "role", role) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> builtins.str: + """ + Openstack network ID. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter + def role(self) -> builtins.str: + """ + The role defines how the load balancer is using the network. Supported values are: `ROLE_UNSPECIFIED`, `ROLE_LISTENERS_AND_TARGETS`, `ROLE_LISTENERS`, `ROLE_TARGETS`. + """ + return pulumi.get(self, "role") + + +@pulumi.output_type +class LoadbalancerOptions(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "privateNetworkOnly": + suggest = "private_network_only" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerOptions. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerOptions.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerOptions.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + acls: Optional[Sequence[builtins.str]] = None, + observability: Optional['outputs.LoadbalancerOptionsObservability'] = None, + private_network_only: Optional[builtins.bool] = None): + """ + :param Sequence[builtins.str] acls: Load Balancer is accessible only from an IP address in this range. + :param 'LoadbalancerOptionsObservabilityArgs' observability: We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + :param builtins.bool private_network_only: If true, Load Balancer is accessible only via a private network IP address. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if observability is not None: + pulumi.set(__self__, "observability", observability) + if private_network_only is not None: + pulumi.set(__self__, "private_network_only", private_network_only) + + @property + @pulumi.getter + def acls(self) -> Optional[Sequence[builtins.str]]: + """ + Load Balancer is accessible only from an IP address in this range. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter + def observability(self) -> Optional['outputs.LoadbalancerOptionsObservability']: + """ + We offer Load Balancer metrics observability via ARGUS or external solutions. Not changeable after creation. + """ + return pulumi.get(self, "observability") + + @property + @pulumi.getter(name="privateNetworkOnly") + def private_network_only(self) -> Optional[builtins.bool]: + """ + If true, Load Balancer is accessible only via a private network IP address. + """ + return pulumi.get(self, "private_network_only") + + +@pulumi.output_type +class LoadbalancerOptionsObservability(dict): + def __init__(__self__, *, + logs: Optional['outputs.LoadbalancerOptionsObservabilityLogs'] = None, + metrics: Optional['outputs.LoadbalancerOptionsObservabilityMetrics'] = None): + """ + :param 'LoadbalancerOptionsObservabilityLogsArgs' logs: Observability logs configuration. Not changeable after creation. + :param 'LoadbalancerOptionsObservabilityMetricsArgs' metrics: Observability metrics configuration. Not changeable after creation. + """ + if logs is not None: + pulumi.set(__self__, "logs", logs) + if metrics is not None: + pulumi.set(__self__, "metrics", metrics) + + @property + @pulumi.getter + def logs(self) -> Optional['outputs.LoadbalancerOptionsObservabilityLogs']: + """ + Observability logs configuration. Not changeable after creation. + """ + return pulumi.get(self, "logs") + + @property + @pulumi.getter + def metrics(self) -> Optional['outputs.LoadbalancerOptionsObservabilityMetrics']: + """ + Observability metrics configuration. Not changeable after creation. + """ + return pulumi.get(self, "metrics") + + +@pulumi.output_type +class LoadbalancerOptionsObservabilityLogs(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsRef": + suggest = "credentials_ref" + elif key == "pushUrl": + suggest = "push_url" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerOptionsObservabilityLogs. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerOptionsObservabilityLogs.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerOptionsObservabilityLogs.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials_ref: Optional[builtins.str] = None, + push_url: Optional[builtins.str] = None): + """ + :param builtins.str credentials_ref: Credentials reference for logs. Not changeable after creation. + :param builtins.str push_url: Credentials reference for logs. Not changeable after creation. + """ + if credentials_ref is not None: + pulumi.set(__self__, "credentials_ref", credentials_ref) + if push_url is not None: + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> Optional[builtins.str]: + """ + Credentials reference for logs. Not changeable after creation. + """ + return pulumi.get(self, "credentials_ref") + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> Optional[builtins.str]: + """ + Credentials reference for logs. Not changeable after creation. + """ + return pulumi.get(self, "push_url") + + +@pulumi.output_type +class LoadbalancerOptionsObservabilityMetrics(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "credentialsRef": + suggest = "credentials_ref" + elif key == "pushUrl": + suggest = "push_url" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerOptionsObservabilityMetrics. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerOptionsObservabilityMetrics.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerOptionsObservabilityMetrics.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + credentials_ref: Optional[builtins.str] = None, + push_url: Optional[builtins.str] = None): + """ + :param builtins.str credentials_ref: Credentials reference for metrics. Not changeable after creation. + :param builtins.str push_url: Credentials reference for metrics. Not changeable after creation. + """ + if credentials_ref is not None: + pulumi.set(__self__, "credentials_ref", credentials_ref) + if push_url is not None: + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> Optional[builtins.str]: + """ + Credentials reference for metrics. Not changeable after creation. + """ + return pulumi.get(self, "credentials_ref") + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> Optional[builtins.str]: + """ + Credentials reference for metrics. Not changeable after creation. + """ + return pulumi.get(self, "push_url") + + +@pulumi.output_type +class LoadbalancerTargetPool(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "targetPort": + suggest = "target_port" + elif key == "activeHealthCheck": + suggest = "active_health_check" + elif key == "sessionPersistence": + suggest = "session_persistence" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerTargetPool. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerTargetPool.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerTargetPool.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name: builtins.str, + target_port: builtins.int, + targets: Sequence['outputs.LoadbalancerTargetPoolTarget'], + active_health_check: Optional['outputs.LoadbalancerTargetPoolActiveHealthCheck'] = None, + session_persistence: Optional['outputs.LoadbalancerTargetPoolSessionPersistence'] = None): + """ + :param builtins.str name: Target pool name. + :param builtins.int target_port: Identical port number where each target listens for traffic. + :param Sequence['LoadbalancerTargetPoolTargetArgs'] targets: List of all targets which will be used in the pool. Limited to 1000. + :param 'LoadbalancerTargetPoolSessionPersistenceArgs' session_persistence: Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "target_port", target_port) + pulumi.set(__self__, "targets", targets) + if active_health_check is not None: + pulumi.set(__self__, "active_health_check", active_health_check) + if session_persistence is not None: + pulumi.set(__self__, "session_persistence", session_persistence) + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Target pool name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="targetPort") + def target_port(self) -> builtins.int: + """ + Identical port number where each target listens for traffic. + """ + return pulumi.get(self, "target_port") + + @property + @pulumi.getter + def targets(self) -> Sequence['outputs.LoadbalancerTargetPoolTarget']: + """ + List of all targets which will be used in the pool. Limited to 1000. + """ + return pulumi.get(self, "targets") + + @property + @pulumi.getter(name="activeHealthCheck") + def active_health_check(self) -> Optional['outputs.LoadbalancerTargetPoolActiveHealthCheck']: + return pulumi.get(self, "active_health_check") + + @property + @pulumi.getter(name="sessionPersistence") + def session_persistence(self) -> Optional['outputs.LoadbalancerTargetPoolSessionPersistence']: + """ + Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + return pulumi.get(self, "session_persistence") + + +@pulumi.output_type +class LoadbalancerTargetPoolActiveHealthCheck(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "healthyThreshold": + suggest = "healthy_threshold" + elif key == "intervalJitter": + suggest = "interval_jitter" + elif key == "unhealthyThreshold": + suggest = "unhealthy_threshold" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerTargetPoolActiveHealthCheck. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerTargetPoolActiveHealthCheck.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerTargetPoolActiveHealthCheck.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + healthy_threshold: Optional[builtins.int] = None, + interval: Optional[builtins.str] = None, + interval_jitter: Optional[builtins.str] = None, + timeout: Optional[builtins.str] = None, + unhealthy_threshold: Optional[builtins.int] = None): + """ + :param builtins.int healthy_threshold: Healthy threshold of the health checking. + :param builtins.str interval: Interval duration of health checking in seconds. + :param builtins.str interval_jitter: Interval duration threshold of the health checking in seconds. + :param builtins.str timeout: Active health checking timeout duration in seconds. + :param builtins.int unhealthy_threshold: Unhealthy threshold of the health checking. + """ + if healthy_threshold is not None: + pulumi.set(__self__, "healthy_threshold", healthy_threshold) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if interval_jitter is not None: + pulumi.set(__self__, "interval_jitter", interval_jitter) + if timeout is not None: + pulumi.set(__self__, "timeout", timeout) + if unhealthy_threshold is not None: + pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold) + + @property + @pulumi.getter(name="healthyThreshold") + def healthy_threshold(self) -> Optional[builtins.int]: + """ + Healthy threshold of the health checking. + """ + return pulumi.get(self, "healthy_threshold") + + @property + @pulumi.getter + def interval(self) -> Optional[builtins.str]: + """ + Interval duration of health checking in seconds. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter(name="intervalJitter") + def interval_jitter(self) -> Optional[builtins.str]: + """ + Interval duration threshold of the health checking in seconds. + """ + return pulumi.get(self, "interval_jitter") + + @property + @pulumi.getter + def timeout(self) -> Optional[builtins.str]: + """ + Active health checking timeout duration in seconds. + """ + return pulumi.get(self, "timeout") + + @property + @pulumi.getter(name="unhealthyThreshold") + def unhealthy_threshold(self) -> Optional[builtins.int]: + """ + Unhealthy threshold of the health checking. + """ + return pulumi.get(self, "unhealthy_threshold") + + +@pulumi.output_type +class LoadbalancerTargetPoolSessionPersistence(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "useSourceIpAddress": + suggest = "use_source_ip_address" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerTargetPoolSessionPersistence. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerTargetPoolSessionPersistence.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerTargetPoolSessionPersistence.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + use_source_ip_address: Optional[builtins.bool] = None): + """ + :param builtins.bool use_source_ip_address: If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + if use_source_ip_address is not None: + pulumi.set(__self__, "use_source_ip_address", use_source_ip_address) + + @property + @pulumi.getter(name="useSourceIpAddress") + def use_source_ip_address(self) -> Optional[builtins.bool]: + """ + If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + return pulumi.get(self, "use_source_ip_address") + + +@pulumi.output_type +class LoadbalancerTargetPoolTarget(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "displayName": + suggest = "display_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LoadbalancerTargetPoolTarget. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LoadbalancerTargetPoolTarget.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LoadbalancerTargetPoolTarget.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + display_name: builtins.str, + ip: builtins.str): + """ + :param builtins.str display_name: Target display name + :param builtins.str ip: Target IP + """ + pulumi.set(__self__, "display_name", display_name) + pulumi.set(__self__, "ip", ip) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> builtins.str: + """ + Target display name + """ + return pulumi.get(self, "display_name") + + @property + @pulumi.getter + def ip(self) -> builtins.str: + """ + Target IP + """ + return pulumi.get(self, "ip") + + +@pulumi.output_type +class LogmeInstanceParameters(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "enableMonitoring": + suggest = "enable_monitoring" + elif key == "fluentdTcp": + suggest = "fluentd_tcp" + elif key == "fluentdTls": + suggest = "fluentd_tls" + elif key == "fluentdTlsCiphers": + suggest = "fluentd_tls_ciphers" + elif key == "fluentdTlsMaxVersion": + suggest = "fluentd_tls_max_version" + elif key == "fluentdTlsMinVersion": + suggest = "fluentd_tls_min_version" + elif key == "fluentdTlsVersion": + suggest = "fluentd_tls_version" + elif key == "fluentdUdp": + suggest = "fluentd_udp" + elif key == "ismDeletionAfter": + suggest = "ism_deletion_after" + elif key == "ismJitter": + suggest = "ism_jitter" + elif key == "ismJobInterval": + suggest = "ism_job_interval" + elif key == "javaHeapspace": + suggest = "java_heapspace" + elif key == "javaMaxmetaspace": + suggest = "java_maxmetaspace" + elif key == "maxDiskThreshold": + suggest = "max_disk_threshold" + elif key == "metricsFrequency": + suggest = "metrics_frequency" + elif key == "metricsPrefix": + suggest = "metrics_prefix" + elif key == "monitoringInstanceId": + suggest = "monitoring_instance_id" + elif key == "opensearchTlsCiphers": + suggest = "opensearch_tls_ciphers" + elif key == "opensearchTlsProtocols": + suggest = "opensearch_tls_protocols" + elif key == "sgwAcl": + suggest = "sgw_acl" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in LogmeInstanceParameters. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + LogmeInstanceParameters.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + LogmeInstanceParameters.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + enable_monitoring: Optional[builtins.bool] = None, + fluentd_tcp: Optional[builtins.int] = None, + fluentd_tls: Optional[builtins.int] = None, + fluentd_tls_ciphers: Optional[builtins.str] = None, + fluentd_tls_max_version: Optional[builtins.str] = None, + fluentd_tls_min_version: Optional[builtins.str] = None, + fluentd_tls_version: Optional[builtins.str] = None, + fluentd_udp: Optional[builtins.int] = None, + graphite: Optional[builtins.str] = None, + ism_deletion_after: Optional[builtins.str] = None, + ism_jitter: Optional[builtins.float] = None, + ism_job_interval: Optional[builtins.int] = None, + java_heapspace: Optional[builtins.int] = None, + java_maxmetaspace: Optional[builtins.int] = None, + max_disk_threshold: Optional[builtins.int] = None, + metrics_frequency: Optional[builtins.int] = None, + metrics_prefix: Optional[builtins.str] = None, + monitoring_instance_id: Optional[builtins.str] = None, + opensearch_tls_ciphers: Optional[Sequence[builtins.str]] = None, + opensearch_tls_protocols: Optional[Sequence[builtins.str]] = None, + sgw_acl: Optional[builtins.str] = None, + syslogs: Optional[Sequence[builtins.str]] = None): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param builtins.str ism_deletion_after: Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + :param builtins.int ism_job_interval: Jitter of the execution time. + :param builtins.int java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param builtins.int java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if fluentd_tcp is not None: + pulumi.set(__self__, "fluentd_tcp", fluentd_tcp) + if fluentd_tls is not None: + pulumi.set(__self__, "fluentd_tls", fluentd_tls) + if fluentd_tls_ciphers is not None: + pulumi.set(__self__, "fluentd_tls_ciphers", fluentd_tls_ciphers) + if fluentd_tls_max_version is not None: + pulumi.set(__self__, "fluentd_tls_max_version", fluentd_tls_max_version) + if fluentd_tls_min_version is not None: + pulumi.set(__self__, "fluentd_tls_min_version", fluentd_tls_min_version) + if fluentd_tls_version is not None: + pulumi.set(__self__, "fluentd_tls_version", fluentd_tls_version) + if fluentd_udp is not None: + pulumi.set(__self__, "fluentd_udp", fluentd_udp) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if ism_deletion_after is not None: + pulumi.set(__self__, "ism_deletion_after", ism_deletion_after) + if ism_jitter is not None: + pulumi.set(__self__, "ism_jitter", ism_jitter) + if ism_job_interval is not None: + pulumi.set(__self__, "ism_job_interval", ism_job_interval) + if java_heapspace is not None: + pulumi.set(__self__, "java_heapspace", java_heapspace) + if java_maxmetaspace is not None: + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if opensearch_tls_ciphers is not None: + pulumi.set(__self__, "opensearch_tls_ciphers", opensearch_tls_ciphers) + if opensearch_tls_protocols is not None: + pulumi.set(__self__, "opensearch_tls_protocols", opensearch_tls_protocols) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[builtins.bool]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter(name="fluentdTcp") + def fluentd_tcp(self) -> Optional[builtins.int]: + return pulumi.get(self, "fluentd_tcp") + + @property + @pulumi.getter(name="fluentdTls") + def fluentd_tls(self) -> Optional[builtins.int]: + return pulumi.get(self, "fluentd_tls") + + @property + @pulumi.getter(name="fluentdTlsCiphers") + def fluentd_tls_ciphers(self) -> Optional[builtins.str]: + return pulumi.get(self, "fluentd_tls_ciphers") + + @property + @pulumi.getter(name="fluentdTlsMaxVersion") + def fluentd_tls_max_version(self) -> Optional[builtins.str]: + return pulumi.get(self, "fluentd_tls_max_version") + + @property + @pulumi.getter(name="fluentdTlsMinVersion") + def fluentd_tls_min_version(self) -> Optional[builtins.str]: + return pulumi.get(self, "fluentd_tls_min_version") + + @property + @pulumi.getter(name="fluentdTlsVersion") + def fluentd_tls_version(self) -> Optional[builtins.str]: + return pulumi.get(self, "fluentd_tls_version") + + @property + @pulumi.getter(name="fluentdUdp") + def fluentd_udp(self) -> Optional[builtins.int]: + return pulumi.get(self, "fluentd_udp") + + @property + @pulumi.getter + def graphite(self) -> Optional[builtins.str]: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="ismDeletionAfter") + def ism_deletion_after(self) -> Optional[builtins.str]: + """ + Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + """ + return pulumi.get(self, "ism_deletion_after") + + @property + @pulumi.getter(name="ismJitter") + def ism_jitter(self) -> Optional[builtins.float]: + return pulumi.get(self, "ism_jitter") + + @property + @pulumi.getter(name="ismJobInterval") + def ism_job_interval(self) -> Optional[builtins.int]: + """ + Jitter of the execution time. + """ + return pulumi.get(self, "ism_job_interval") + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> Optional[builtins.int]: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> Optional[builtins.int]: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[builtins.int]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[builtins.int]: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[builtins.str]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[builtins.str]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="opensearchTlsCiphers") + def opensearch_tls_ciphers(self) -> Optional[Sequence[builtins.str]]: + return pulumi.get(self, "opensearch_tls_ciphers") + + @property + @pulumi.getter(name="opensearchTlsProtocols") + def opensearch_tls_protocols(self) -> Optional[Sequence[builtins.str]]: + return pulumi.get(self, "opensearch_tls_protocols") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[builtins.str]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Optional[Sequence[builtins.str]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + +@pulumi.output_type +class MariadbInstanceParameters(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "enableMonitoring": + suggest = "enable_monitoring" + elif key == "maxDiskThreshold": + suggest = "max_disk_threshold" + elif key == "metricsFrequency": + suggest = "metrics_frequency" + elif key == "metricsPrefix": + suggest = "metrics_prefix" + elif key == "monitoringInstanceId": + suggest = "monitoring_instance_id" + elif key == "sgwAcl": + suggest = "sgw_acl" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MariadbInstanceParameters. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MariadbInstanceParameters.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MariadbInstanceParameters.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + enable_monitoring: Optional[builtins.bool] = None, + graphite: Optional[builtins.str] = None, + max_disk_threshold: Optional[builtins.int] = None, + metrics_frequency: Optional[builtins.int] = None, + metrics_prefix: Optional[builtins.str] = None, + monitoring_instance_id: Optional[builtins.str] = None, + sgw_acl: Optional[builtins.str] = None, + syslogs: Optional[Sequence[builtins.str]] = None): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[builtins.bool]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> Optional[builtins.str]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[builtins.int]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[builtins.int]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[builtins.str]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[builtins.str]: + """ + The ID of the STACKIT monitoring instance. Monitoring instances with the plan "Observability-Monitoring-Starter" are not supported. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[builtins.str]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Optional[Sequence[builtins.str]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + +@pulumi.output_type +class MongodbflexInstanceFlavor(dict): + def __init__(__self__, *, + cpu: builtins.int, + ram: builtins.int, + description: Optional[builtins.str] = None, + id: Optional[builtins.str] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + @property + @pulumi.getter + def description(self) -> Optional[builtins.str]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> Optional[builtins.str]: + return pulumi.get(self, "id") + + +@pulumi.output_type +class MongodbflexInstanceOptions(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "pointInTimeWindowHours": + suggest = "point_in_time_window_hours" + elif key == "dailySnapshotRetentionDays": + suggest = "daily_snapshot_retention_days" + elif key == "monthlySnapshotRetentionMonths": + suggest = "monthly_snapshot_retention_months" + elif key == "snapshotRetentionDays": + suggest = "snapshot_retention_days" + elif key == "weeklySnapshotRetentionWeeks": + suggest = "weekly_snapshot_retention_weeks" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MongodbflexInstanceOptions. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MongodbflexInstanceOptions.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MongodbflexInstanceOptions.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + point_in_time_window_hours: builtins.int, + type: builtins.str, + daily_snapshot_retention_days: Optional[builtins.int] = None, + monthly_snapshot_retention_months: Optional[builtins.int] = None, + snapshot_retention_days: Optional[builtins.int] = None, + weekly_snapshot_retention_weeks: Optional[builtins.int] = None): + """ + :param builtins.int point_in_time_window_hours: The number of hours back in time the point-in-time recovery feature will be able to recover. + :param builtins.str type: Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + :param builtins.int daily_snapshot_retention_days: The number of days that daily backups will be retained. + :param builtins.int monthly_snapshot_retention_months: The number of months that monthly backups will be retained. + :param builtins.int snapshot_retention_days: The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + :param builtins.int weekly_snapshot_retention_weeks: The number of weeks that weekly backups will be retained. + """ + pulumi.set(__self__, "point_in_time_window_hours", point_in_time_window_hours) + pulumi.set(__self__, "type", type) + if daily_snapshot_retention_days is not None: + pulumi.set(__self__, "daily_snapshot_retention_days", daily_snapshot_retention_days) + if monthly_snapshot_retention_months is not None: + pulumi.set(__self__, "monthly_snapshot_retention_months", monthly_snapshot_retention_months) + if snapshot_retention_days is not None: + pulumi.set(__self__, "snapshot_retention_days", snapshot_retention_days) + if weekly_snapshot_retention_weeks is not None: + pulumi.set(__self__, "weekly_snapshot_retention_weeks", weekly_snapshot_retention_weeks) + + @property + @pulumi.getter(name="pointInTimeWindowHours") + def point_in_time_window_hours(self) -> builtins.int: + """ + The number of hours back in time the point-in-time recovery feature will be able to recover. + """ + return pulumi.get(self, "point_in_time_window_hours") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + Type of the MongoDB Flex instance. Supported values are: `Replica`, `Sharded`, `Single`. + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="dailySnapshotRetentionDays") + def daily_snapshot_retention_days(self) -> Optional[builtins.int]: + """ + The number of days that daily backups will be retained. + """ + return pulumi.get(self, "daily_snapshot_retention_days") + + @property + @pulumi.getter(name="monthlySnapshotRetentionMonths") + def monthly_snapshot_retention_months(self) -> Optional[builtins.int]: + """ + The number of months that monthly backups will be retained. + """ + return pulumi.get(self, "monthly_snapshot_retention_months") + + @property + @pulumi.getter(name="snapshotRetentionDays") + def snapshot_retention_days(self) -> Optional[builtins.int]: + """ + The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + """ + return pulumi.get(self, "snapshot_retention_days") + + @property + @pulumi.getter(name="weeklySnapshotRetentionWeeks") + def weekly_snapshot_retention_weeks(self) -> Optional[builtins.int]: + """ + The number of weeks that weekly backups will be retained. + """ + return pulumi.get(self, "weekly_snapshot_retention_weeks") + + +@pulumi.output_type +class MongodbflexInstanceStorage(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "class": + suggest = "class_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MongodbflexInstanceStorage. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MongodbflexInstanceStorage.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MongodbflexInstanceStorage.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + class_: builtins.str, + size: builtins.int): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> builtins.str: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> builtins.int: + return pulumi.get(self, "size") + + +@pulumi.output_type +class NetworkAreaNetworkRange(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "networkRangeId": + suggest = "network_range_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in NetworkAreaNetworkRange. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + NetworkAreaNetworkRange.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + NetworkAreaNetworkRange.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + prefix: builtins.str, + network_range_id: Optional[builtins.str] = None): + """ + :param builtins.str prefix: Classless Inter-Domain Routing (CIDR). + """ + pulumi.set(__self__, "prefix", prefix) + if network_range_id is not None: + pulumi.set(__self__, "network_range_id", network_range_id) + + @property + @pulumi.getter + def prefix(self) -> builtins.str: + """ + Classless Inter-Domain Routing (CIDR). + """ + return pulumi.get(self, "prefix") + + @property + @pulumi.getter(name="networkRangeId") + def network_range_id(self) -> Optional[builtins.str]: + return pulumi.get(self, "network_range_id") + + +@pulumi.output_type +class ObservabilityAlertgroupRule(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "for": + suggest = "for_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityAlertgroupRule. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityAlertgroupRule.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityAlertgroupRule.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alert: builtins.str, + expression: builtins.str, + annotations: Optional[Mapping[str, builtins.str]] = None, + for_: Optional[builtins.str] = None, + labels: Optional[Mapping[str, builtins.str]] = None): + """ + :param builtins.str alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param builtins.str expression: The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param Mapping[str, builtins.str] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param builtins.str for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param Mapping[str, builtins.str] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "expression", expression) + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if for_ is not None: + pulumi.set(__self__, "for_", for_) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> builtins.str: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @property + @pulumi.getter + def expression(self) -> builtins.str: + """ + The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @property + @pulumi.getter + def annotations(self) -> Optional[Mapping[str, builtins.str]]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @property + @pulumi.getter(name="for") + def for_(self) -> Optional[builtins.str]: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, builtins.str]]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "global": + suggest = "global_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + receivers: Sequence['outputs.ObservabilityInstanceAlertConfigReceiver'], + route: 'outputs.ObservabilityInstanceAlertConfigRoute', + global_: Optional['outputs.ObservabilityInstanceAlertConfigGlobal'] = None): + """ + :param Sequence['ObservabilityInstanceAlertConfigReceiverArgs'] receivers: List of alert receivers. + :param 'ObservabilityInstanceAlertConfigRouteArgs' route: Route configuration for the alerts. + :param 'ObservabilityInstanceAlertConfigGlobalArgs' global_: Global configuration for the alerts. + """ + pulumi.set(__self__, "receivers", receivers) + pulumi.set(__self__, "route", route) + if global_ is not None: + pulumi.set(__self__, "global_", global_) + + @property + @pulumi.getter + def receivers(self) -> Sequence['outputs.ObservabilityInstanceAlertConfigReceiver']: + """ + List of alert receivers. + """ + return pulumi.get(self, "receivers") + + @property + @pulumi.getter + def route(self) -> 'outputs.ObservabilityInstanceAlertConfigRoute': + """ + Route configuration for the alerts. + """ + return pulumi.get(self, "route") + + @property + @pulumi.getter(name="global") + def global_(self) -> Optional['outputs.ObservabilityInstanceAlertConfigGlobal']: + """ + Global configuration for the alerts. + """ + return pulumi.get(self, "global_") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigGlobal(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "opsgenieApiKey": + suggest = "opsgenie_api_key" + elif key == "opsgenieApiUrl": + suggest = "opsgenie_api_url" + elif key == "resolveTimeout": + suggest = "resolve_timeout" + elif key == "smtpAuthIdentity": + suggest = "smtp_auth_identity" + elif key == "smtpAuthPassword": + suggest = "smtp_auth_password" + elif key == "smtpAuthUsername": + suggest = "smtp_auth_username" + elif key == "smtpFrom": + suggest = "smtp_from" + elif key == "smtpSmartHost": + suggest = "smtp_smart_host" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigGlobal. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigGlobal.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigGlobal.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + opsgenie_api_key: Optional[builtins.str] = None, + opsgenie_api_url: Optional[builtins.str] = None, + resolve_timeout: Optional[builtins.str] = None, + smtp_auth_identity: Optional[builtins.str] = None, + smtp_auth_password: Optional[builtins.str] = None, + smtp_auth_username: Optional[builtins.str] = None, + smtp_from: Optional[builtins.str] = None, + smtp_smart_host: Optional[builtins.str] = None): + """ + :param builtins.str opsgenie_api_key: The API key for OpsGenie. + :param builtins.str opsgenie_api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param builtins.str resolve_timeout: The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + :param builtins.str smtp_auth_identity: SMTP authentication information. Must be a valid email address + :param builtins.str smtp_auth_password: SMTP Auth using LOGIN and PLAIN. + :param builtins.str smtp_auth_username: SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + :param builtins.str smtp_from: The default SMTP From header field. Must be a valid email address + :param builtins.str smtp_smart_host: The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + if opsgenie_api_key is not None: + pulumi.set(__self__, "opsgenie_api_key", opsgenie_api_key) + if opsgenie_api_url is not None: + pulumi.set(__self__, "opsgenie_api_url", opsgenie_api_url) + if resolve_timeout is not None: + pulumi.set(__self__, "resolve_timeout", resolve_timeout) + if smtp_auth_identity is not None: + pulumi.set(__self__, "smtp_auth_identity", smtp_auth_identity) + if smtp_auth_password is not None: + pulumi.set(__self__, "smtp_auth_password", smtp_auth_password) + if smtp_auth_username is not None: + pulumi.set(__self__, "smtp_auth_username", smtp_auth_username) + if smtp_from is not None: + pulumi.set(__self__, "smtp_from", smtp_from) + if smtp_smart_host is not None: + pulumi.set(__self__, "smtp_smart_host", smtp_smart_host) + + @property + @pulumi.getter(name="opsgenieApiKey") + def opsgenie_api_key(self) -> Optional[builtins.str]: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "opsgenie_api_key") + + @property + @pulumi.getter(name="opsgenieApiUrl") + def opsgenie_api_url(self) -> Optional[builtins.str]: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "opsgenie_api_url") + + @property + @pulumi.getter(name="resolveTimeout") + def resolve_timeout(self) -> Optional[builtins.str]: + """ + The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + """ + return pulumi.get(self, "resolve_timeout") + + @property + @pulumi.getter(name="smtpAuthIdentity") + def smtp_auth_identity(self) -> Optional[builtins.str]: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "smtp_auth_identity") + + @property + @pulumi.getter(name="smtpAuthPassword") + def smtp_auth_password(self) -> Optional[builtins.str]: + """ + SMTP Auth using LOGIN and PLAIN. + """ + return pulumi.get(self, "smtp_auth_password") + + @property + @pulumi.getter(name="smtpAuthUsername") + def smtp_auth_username(self) -> Optional[builtins.str]: + """ + SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + """ + return pulumi.get(self, "smtp_auth_username") + + @property + @pulumi.getter(name="smtpFrom") + def smtp_from(self) -> Optional[builtins.str]: + """ + The default SMTP From header field. Must be a valid email address + """ + return pulumi.get(self, "smtp_from") + + @property + @pulumi.getter(name="smtpSmartHost") + def smtp_smart_host(self) -> Optional[builtins.str]: + """ + The default SMTP smarthost used for sending emails, including port number in format `host:port` (eg. `smtp.example.com:587`). Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + return pulumi.get(self, "smtp_smart_host") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigReceiver(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "emailConfigs": + suggest = "email_configs" + elif key == "opsgenieConfigs": + suggest = "opsgenie_configs" + elif key == "webhooksConfigs": + suggest = "webhooks_configs" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigReceiver. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigReceiver.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigReceiver.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name: builtins.str, + email_configs: Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverEmailConfig']] = None, + opsgenie_configs: Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverOpsgenieConfig']] = None, + webhooks_configs: Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverWebhooksConfig']] = None): + """ + :param builtins.str name: Name of the receiver. + :param Sequence['ObservabilityInstanceAlertConfigReceiverEmailConfigArgs'] email_configs: List of email configurations. + :param Sequence['ObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs'] opsgenie_configs: List of OpsGenie configurations. + :param Sequence['ObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs'] webhooks_configs: List of Webhooks configurations. + """ + pulumi.set(__self__, "name", name) + if email_configs is not None: + pulumi.set(__self__, "email_configs", email_configs) + if opsgenie_configs is not None: + pulumi.set(__self__, "opsgenie_configs", opsgenie_configs) + if webhooks_configs is not None: + pulumi.set(__self__, "webhooks_configs", webhooks_configs) + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Name of the receiver. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="emailConfigs") + def email_configs(self) -> Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverEmailConfig']]: + """ + List of email configurations. + """ + return pulumi.get(self, "email_configs") + + @property + @pulumi.getter(name="opsgenieConfigs") + def opsgenie_configs(self) -> Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverOpsgenieConfig']]: + """ + List of OpsGenie configurations. + """ + return pulumi.get(self, "opsgenie_configs") + + @property + @pulumi.getter(name="webhooksConfigs") + def webhooks_configs(self) -> Optional[Sequence['outputs.ObservabilityInstanceAlertConfigReceiverWebhooksConfig']]: + """ + List of Webhooks configurations. + """ + return pulumi.get(self, "webhooks_configs") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigReceiverEmailConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "authIdentity": + suggest = "auth_identity" + elif key == "authPassword": + suggest = "auth_password" + elif key == "authUsername": + suggest = "auth_username" + elif key == "from": + suggest = "from_" + elif key == "smartHost": + suggest = "smart_host" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigReceiverEmailConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigReceiverEmailConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigReceiverEmailConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + auth_identity: Optional[builtins.str] = None, + auth_password: Optional[builtins.str] = None, + auth_username: Optional[builtins.str] = None, + from_: Optional[builtins.str] = None, + smart_host: Optional[builtins.str] = None, + to: Optional[builtins.str] = None): + """ + :param builtins.str auth_identity: SMTP authentication information. Must be a valid email address + :param builtins.str auth_password: SMTP authentication password. + :param builtins.str auth_username: SMTP authentication username. + :param builtins.str from_: The sender email address. Must be a valid email address + :param builtins.str smart_host: The SMTP host through which emails are sent. + :param builtins.str to: The email address to send notifications to. Must be a valid email address + """ + if auth_identity is not None: + pulumi.set(__self__, "auth_identity", auth_identity) + if auth_password is not None: + pulumi.set(__self__, "auth_password", auth_password) + if auth_username is not None: + pulumi.set(__self__, "auth_username", auth_username) + if from_ is not None: + pulumi.set(__self__, "from_", from_) + if smart_host is not None: + pulumi.set(__self__, "smart_host", smart_host) + if to is not None: + pulumi.set(__self__, "to", to) + + @property + @pulumi.getter(name="authIdentity") + def auth_identity(self) -> Optional[builtins.str]: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "auth_identity") + + @property + @pulumi.getter(name="authPassword") + def auth_password(self) -> Optional[builtins.str]: + """ + SMTP authentication password. + """ + return pulumi.get(self, "auth_password") + + @property + @pulumi.getter(name="authUsername") + def auth_username(self) -> Optional[builtins.str]: + """ + SMTP authentication username. + """ + return pulumi.get(self, "auth_username") + + @property + @pulumi.getter(name="from") + def from_(self) -> Optional[builtins.str]: + """ + The sender email address. Must be a valid email address + """ + return pulumi.get(self, "from_") + + @property + @pulumi.getter(name="smartHost") + def smart_host(self) -> Optional[builtins.str]: + """ + The SMTP host through which emails are sent. + """ + return pulumi.get(self, "smart_host") + + @property + @pulumi.getter + def to(self) -> Optional[builtins.str]: + """ + The email address to send notifications to. Must be a valid email address + """ + return pulumi.get(self, "to") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigReceiverOpsgenieConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "apiKey": + suggest = "api_key" + elif key == "apiUrl": + suggest = "api_url" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigReceiverOpsgenieConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigReceiverOpsgenieConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigReceiverOpsgenieConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + api_key: Optional[builtins.str] = None, + api_url: Optional[builtins.str] = None, + tags: Optional[builtins.str] = None): + """ + :param builtins.str api_key: The API key for OpsGenie. + :param builtins.str api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param builtins.str tags: Comma separated list of tags attached to the notifications. + """ + if api_key is not None: + pulumi.set(__self__, "api_key", api_key) + if api_url is not None: + pulumi.set(__self__, "api_url", api_url) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> Optional[builtins.str]: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "api_key") + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[builtins.str]: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "api_url") + + @property + @pulumi.getter + def tags(self) -> Optional[builtins.str]: + """ + Comma separated list of tags attached to the notifications. + """ + return pulumi.get(self, "tags") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigReceiverWebhooksConfig(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "msTeams": + suggest = "ms_teams" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigReceiverWebhooksConfig. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigReceiverWebhooksConfig.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigReceiverWebhooksConfig.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + ms_teams: Optional[builtins.bool] = None, + url: Optional[builtins.str] = None): + """ + :param builtins.bool ms_teams: Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + :param builtins.str url: The endpoint to send HTTP POST requests to. Must be a valid URL + """ + if ms_teams is not None: + pulumi.set(__self__, "ms_teams", ms_teams) + if url is not None: + pulumi.set(__self__, "url", url) + + @property + @pulumi.getter(name="msTeams") + def ms_teams(self) -> Optional[builtins.bool]: + """ + Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + """ + return pulumi.get(self, "ms_teams") + + @property + @pulumi.getter + def url(self) -> Optional[builtins.str]: + """ + The endpoint to send HTTP POST requests to. Must be a valid URL + """ + return pulumi.get(self, "url") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigRoute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "groupBies": + suggest = "group_bies" + elif key == "groupInterval": + suggest = "group_interval" + elif key == "groupWait": + suggest = "group_wait" + elif key == "matchRegex": + suggest = "match_regex" + elif key == "repeatInterval": + suggest = "repeat_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigRoute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigRoute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigRoute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + receiver: builtins.str, + group_bies: Optional[Sequence[builtins.str]] = None, + group_interval: Optional[builtins.str] = None, + group_wait: Optional[builtins.str] = None, + match: Optional[Mapping[str, builtins.str]] = None, + match_regex: Optional[Mapping[str, builtins.str]] = None, + repeat_interval: Optional[builtins.str] = None, + routes: Optional[Sequence['outputs.ObservabilityInstanceAlertConfigRouteRoute']] = None): + """ + :param builtins.str receiver: The name of the receiver to route the alerts to. + :param Sequence[builtins.str] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param builtins.str group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param builtins.str group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + :param Mapping[str, builtins.str] match: A set of equality matchers an alert has to fulfill to match the node. + :param Mapping[str, builtins.str] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param builtins.str repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + :param Sequence['ObservabilityInstanceAlertConfigRouteRouteArgs'] routes: List of child routes. + """ + pulumi.set(__self__, "receiver", receiver) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if group_interval is not None: + pulumi.set(__self__, "group_interval", group_interval) + if group_wait is not None: + pulumi.set(__self__, "group_wait", group_wait) + if match is not None: + pulumi.set(__self__, "match", match) + if match_regex is not None: + pulumi.set(__self__, "match_regex", match_regex) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter + def receiver(self) -> builtins.str: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[Sequence[builtins.str]]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> Optional[builtins.str]: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> Optional[builtins.str]: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + return pulumi.get(self, "group_wait") + + @property + @pulumi.getter + def match(self) -> Optional[Mapping[str, builtins.str]]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Optional[Mapping[str, builtins.str]]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[builtins.str]: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + @property + @pulumi.getter + def routes(self) -> Optional[Sequence['outputs.ObservabilityInstanceAlertConfigRouteRoute']]: + """ + List of child routes. + """ + return pulumi.get(self, "routes") + + +@pulumi.output_type +class ObservabilityInstanceAlertConfigRouteRoute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "groupBies": + suggest = "group_bies" + elif key == "groupInterval": + suggest = "group_interval" + elif key == "groupWait": + suggest = "group_wait" + elif key == "matchRegex": + suggest = "match_regex" + elif key == "repeatInterval": + suggest = "repeat_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityInstanceAlertConfigRouteRoute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityInstanceAlertConfigRouteRoute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityInstanceAlertConfigRouteRoute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + receiver: builtins.str, + group_bies: Optional[Sequence[builtins.str]] = None, + group_interval: Optional[builtins.str] = None, + group_wait: Optional[builtins.str] = None, + match: Optional[Mapping[str, builtins.str]] = None, + match_regex: Optional[Mapping[str, builtins.str]] = None, + repeat_interval: Optional[builtins.str] = None): + """ + :param builtins.str receiver: The name of the receiver to route the alerts to. + :param Sequence[builtins.str] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param builtins.str group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param builtins.str group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + :param Mapping[str, builtins.str] match: A set of equality matchers an alert has to fulfill to match the node. + :param Mapping[str, builtins.str] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param builtins.str repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + pulumi.set(__self__, "receiver", receiver) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if group_interval is not None: + pulumi.set(__self__, "group_interval", group_interval) + if group_wait is not None: + pulumi.set(__self__, "group_wait", group_wait) + if match is not None: + pulumi.set(__self__, "match", match) + if match_regex is not None: + pulumi.set(__self__, "match_regex", match_regex) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def receiver(self) -> builtins.str: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[Sequence[builtins.str]]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> Optional[builtins.str]: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> Optional[builtins.str]: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + return pulumi.get(self, "group_wait") + + @property + @pulumi.getter + def match(self) -> Optional[Mapping[str, builtins.str]]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Optional[Mapping[str, builtins.str]]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[builtins.str]: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class ObservabilityLogalertgroupRule(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "for": + suggest = "for_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityLogalertgroupRule. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityLogalertgroupRule.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityLogalertgroupRule.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alert: builtins.str, + expression: builtins.str, + annotations: Optional[Mapping[str, builtins.str]] = None, + for_: Optional[builtins.str] = None, + labels: Optional[Mapping[str, builtins.str]] = None): + """ + :param builtins.str alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param builtins.str expression: The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param Mapping[str, builtins.str] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param builtins.str for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param Mapping[str, builtins.str] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "expression", expression) + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if for_ is not None: + pulumi.set(__self__, "for_", for_) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> builtins.str: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @property + @pulumi.getter + def expression(self) -> builtins.str: + """ + The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @property + @pulumi.getter + def annotations(self) -> Optional[Mapping[str, builtins.str]]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @property + @pulumi.getter(name="for") + def for_(self) -> Optional[builtins.str]: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, builtins.str]]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + +@pulumi.output_type +class ObservabilityScrapeconfigBasicAuth(dict): + def __init__(__self__, *, + password: builtins.str, + username: builtins.str): + """ + :param builtins.str password: Specifies basic auth password. + :param builtins.str username: Specifies basic auth username. + """ + pulumi.set(__self__, "password", password) + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def password(self) -> builtins.str: + """ + Specifies basic auth password. + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter + def username(self) -> builtins.str: + """ + Specifies basic auth username. + """ + return pulumi.get(self, "username") + + +@pulumi.output_type +class ObservabilityScrapeconfigSaml2(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "enableUrlParameters": + suggest = "enable_url_parameters" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ObservabilityScrapeconfigSaml2. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ObservabilityScrapeconfigSaml2.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ObservabilityScrapeconfigSaml2.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + enable_url_parameters: Optional[builtins.bool] = None): + """ + :param builtins.bool enable_url_parameters: Specifies if URL parameters are enabled. Defaults to `true` + """ + if enable_url_parameters is not None: + pulumi.set(__self__, "enable_url_parameters", enable_url_parameters) + + @property + @pulumi.getter(name="enableUrlParameters") + def enable_url_parameters(self) -> Optional[builtins.bool]: + """ + Specifies if URL parameters are enabled. Defaults to `true` + """ + return pulumi.get(self, "enable_url_parameters") + + +@pulumi.output_type +class ObservabilityScrapeconfigTarget(dict): + def __init__(__self__, *, + urls: Sequence[builtins.str], + labels: Optional[Mapping[str, builtins.str]] = None): + """ + :param Sequence[builtins.str] urls: Specifies target URLs. + :param Mapping[str, builtins.str] labels: Specifies labels. + """ + pulumi.set(__self__, "urls", urls) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def urls(self) -> Sequence[builtins.str]: + """ + Specifies target URLs. + """ + return pulumi.get(self, "urls") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, builtins.str]]: + """ + Specifies labels. + """ + return pulumi.get(self, "labels") + + +@pulumi.output_type +class OpensearchInstanceParameters(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "enableMonitoring": + suggest = "enable_monitoring" + elif key == "javaGarbageCollector": + suggest = "java_garbage_collector" + elif key == "javaHeapspace": + suggest = "java_heapspace" + elif key == "javaMaxmetaspace": + suggest = "java_maxmetaspace" + elif key == "maxDiskThreshold": + suggest = "max_disk_threshold" + elif key == "metricsFrequency": + suggest = "metrics_frequency" + elif key == "metricsPrefix": + suggest = "metrics_prefix" + elif key == "monitoringInstanceId": + suggest = "monitoring_instance_id" + elif key == "sgwAcl": + suggest = "sgw_acl" + elif key == "tlsCiphers": + suggest = "tls_ciphers" + elif key == "tlsProtocols": + suggest = "tls_protocols" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in OpensearchInstanceParameters. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + OpensearchInstanceParameters.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + OpensearchInstanceParameters.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + enable_monitoring: Optional[builtins.bool] = None, + graphite: Optional[builtins.str] = None, + java_garbage_collector: Optional[builtins.str] = None, + java_heapspace: Optional[builtins.int] = None, + java_maxmetaspace: Optional[builtins.int] = None, + max_disk_threshold: Optional[builtins.int] = None, + metrics_frequency: Optional[builtins.int] = None, + metrics_prefix: Optional[builtins.str] = None, + monitoring_instance_id: Optional[builtins.str] = None, + plugins: Optional[Sequence[builtins.str]] = None, + sgw_acl: Optional[builtins.str] = None, + syslogs: Optional[Sequence[builtins.str]] = None, + tls_ciphers: Optional[Sequence[builtins.str]] = None, + tls_protocols: Optional[builtins.str] = None): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param builtins.str java_garbage_collector: The garbage collector to use for OpenSearch. + :param builtins.int java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param builtins.int java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param Sequence[builtins.str] plugins: List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_protocols: The TLS protocol to use. + """ + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if java_garbage_collector is not None: + pulumi.set(__self__, "java_garbage_collector", java_garbage_collector) + if java_heapspace is not None: + pulumi.set(__self__, "java_heapspace", java_heapspace) + if java_maxmetaspace is not None: + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if plugins is not None: + pulumi.set(__self__, "plugins", plugins) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[builtins.bool]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> Optional[builtins.str]: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="javaGarbageCollector") + def java_garbage_collector(self) -> Optional[builtins.str]: + """ + The garbage collector to use for OpenSearch. + """ + return pulumi.get(self, "java_garbage_collector") + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> Optional[builtins.int]: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> Optional[builtins.int]: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[builtins.int]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[builtins.int]: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[builtins.str]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[builtins.str]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter + def plugins(self) -> Optional[Sequence[builtins.str]]: + """ + List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + """ + return pulumi.get(self, "plugins") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[builtins.str]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Optional[Sequence[builtins.str]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[Sequence[builtins.str]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[builtins.str]: + """ + The TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class PostgresflexInstanceFlavor(dict): + def __init__(__self__, *, + cpu: builtins.int, + ram: builtins.int, + description: Optional[builtins.str] = None, + id: Optional[builtins.str] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + @property + @pulumi.getter + def description(self) -> Optional[builtins.str]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> Optional[builtins.str]: + return pulumi.get(self, "id") + + +@pulumi.output_type +class PostgresflexInstanceStorage(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "class": + suggest = "class_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in PostgresflexInstanceStorage. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + PostgresflexInstanceStorage.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + PostgresflexInstanceStorage.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + class_: builtins.str, + size: builtins.int): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> builtins.str: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> builtins.int: + return pulumi.get(self, "size") + + +@pulumi.output_type +class RabbitmqInstanceParameters(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "consumerTimeout": + suggest = "consumer_timeout" + elif key == "enableMonitoring": + suggest = "enable_monitoring" + elif key == "maxDiskThreshold": + suggest = "max_disk_threshold" + elif key == "metricsFrequency": + suggest = "metrics_frequency" + elif key == "metricsPrefix": + suggest = "metrics_prefix" + elif key == "monitoringInstanceId": + suggest = "monitoring_instance_id" + elif key == "sgwAcl": + suggest = "sgw_acl" + elif key == "tlsCiphers": + suggest = "tls_ciphers" + elif key == "tlsProtocols": + suggest = "tls_protocols" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in RabbitmqInstanceParameters. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + RabbitmqInstanceParameters.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + RabbitmqInstanceParameters.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + consumer_timeout: Optional[builtins.int] = None, + enable_monitoring: Optional[builtins.bool] = None, + graphite: Optional[builtins.str] = None, + max_disk_threshold: Optional[builtins.int] = None, + metrics_frequency: Optional[builtins.int] = None, + metrics_prefix: Optional[builtins.str] = None, + monitoring_instance_id: Optional[builtins.str] = None, + plugins: Optional[Sequence[builtins.str]] = None, + roles: Optional[Sequence[builtins.str]] = None, + sgw_acl: Optional[builtins.str] = None, + syslogs: Optional[Sequence[builtins.str]] = None, + tls_ciphers: Optional[Sequence[builtins.str]] = None, + tls_protocols: Optional[builtins.str] = None): + """ + :param builtins.int consumer_timeout: The timeout in milliseconds for the consumer. + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param Sequence[builtins.str] plugins: List of plugins to install. Must be a supported plugin name. + :param Sequence[builtins.str] roles: List of roles to assign to the instance. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_protocols: TLS protocol to use. + """ + if consumer_timeout is not None: + pulumi.set(__self__, "consumer_timeout", consumer_timeout) + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if plugins is not None: + pulumi.set(__self__, "plugins", plugins) + if roles is not None: + pulumi.set(__self__, "roles", roles) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="consumerTimeout") + def consumer_timeout(self) -> Optional[builtins.int]: + """ + The timeout in milliseconds for the consumer. + """ + return pulumi.get(self, "consumer_timeout") + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[builtins.bool]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> Optional[builtins.str]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[builtins.int]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[builtins.int]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[builtins.str]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[builtins.str]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter + def plugins(self) -> Optional[Sequence[builtins.str]]: + """ + List of plugins to install. Must be a supported plugin name. + """ + return pulumi.get(self, "plugins") + + @property + @pulumi.getter + def roles(self) -> Optional[Sequence[builtins.str]]: + """ + List of roles to assign to the instance. + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[builtins.str]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Optional[Sequence[builtins.str]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[Sequence[builtins.str]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[builtins.str]: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class RedisInstanceParameters(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "downAfterMilliseconds": + suggest = "down_after_milliseconds" + elif key == "enableMonitoring": + suggest = "enable_monitoring" + elif key == "failoverTimeout": + suggest = "failover_timeout" + elif key == "lazyfreeLazyEviction": + suggest = "lazyfree_lazy_eviction" + elif key == "lazyfreeLazyExpire": + suggest = "lazyfree_lazy_expire" + elif key == "luaTimeLimit": + suggest = "lua_time_limit" + elif key == "maxDiskThreshold": + suggest = "max_disk_threshold" + elif key == "maxmemoryPolicy": + suggest = "maxmemory_policy" + elif key == "maxmemorySamples": + suggest = "maxmemory_samples" + elif key == "metricsFrequency": + suggest = "metrics_frequency" + elif key == "metricsPrefix": + suggest = "metrics_prefix" + elif key == "minReplicasMaxLag": + suggest = "min_replicas_max_lag" + elif key == "monitoringInstanceId": + suggest = "monitoring_instance_id" + elif key == "notifyKeyspaceEvents": + suggest = "notify_keyspace_events" + elif key == "sgwAcl": + suggest = "sgw_acl" + elif key == "tlsCiphers": + suggest = "tls_ciphers" + elif key == "tlsCiphersuites": + suggest = "tls_ciphersuites" + elif key == "tlsProtocols": + suggest = "tls_protocols" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in RedisInstanceParameters. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + RedisInstanceParameters.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + RedisInstanceParameters.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + down_after_milliseconds: Optional[builtins.int] = None, + enable_monitoring: Optional[builtins.bool] = None, + failover_timeout: Optional[builtins.int] = None, + graphite: Optional[builtins.str] = None, + lazyfree_lazy_eviction: Optional[builtins.str] = None, + lazyfree_lazy_expire: Optional[builtins.str] = None, + lua_time_limit: Optional[builtins.int] = None, + max_disk_threshold: Optional[builtins.int] = None, + maxclients: Optional[builtins.int] = None, + maxmemory_policy: Optional[builtins.str] = None, + maxmemory_samples: Optional[builtins.int] = None, + metrics_frequency: Optional[builtins.int] = None, + metrics_prefix: Optional[builtins.str] = None, + min_replicas_max_lag: Optional[builtins.int] = None, + monitoring_instance_id: Optional[builtins.str] = None, + notify_keyspace_events: Optional[builtins.str] = None, + sgw_acl: Optional[builtins.str] = None, + snapshot: Optional[builtins.str] = None, + syslogs: Optional[Sequence[builtins.str]] = None, + tls_ciphers: Optional[Sequence[builtins.str]] = None, + tls_ciphersuites: Optional[builtins.str] = None, + tls_protocols: Optional[builtins.str] = None): + """ + :param builtins.int down_after_milliseconds: The number of milliseconds after which the instance is considered down. + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.int failover_timeout: The failover timeout in milliseconds. + :param builtins.str graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param builtins.str lazyfree_lazy_eviction: The lazy eviction enablement (yes or no). + :param builtins.str lazyfree_lazy_expire: The lazy expire enablement (yes or no). + :param builtins.int lua_time_limit: The Lua time limit. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int maxclients: The maximum number of clients. + :param builtins.str maxmemory_policy: The policy to handle the maximum memory (volatile-lru, noeviction, etc). + :param builtins.int maxmemory_samples: The maximum memory samples. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.int min_replicas_max_lag: The minimum replicas maximum lag. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param builtins.str notify_keyspace_events: The notify keyspace events. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param builtins.str snapshot: The snapshot configuration. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_ciphersuites: TLS cipher suites to use. + :param builtins.str tls_protocols: TLS protocol to use. + """ + if down_after_milliseconds is not None: + pulumi.set(__self__, "down_after_milliseconds", down_after_milliseconds) + if enable_monitoring is not None: + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + if failover_timeout is not None: + pulumi.set(__self__, "failover_timeout", failover_timeout) + if graphite is not None: + pulumi.set(__self__, "graphite", graphite) + if lazyfree_lazy_eviction is not None: + pulumi.set(__self__, "lazyfree_lazy_eviction", lazyfree_lazy_eviction) + if lazyfree_lazy_expire is not None: + pulumi.set(__self__, "lazyfree_lazy_expire", lazyfree_lazy_expire) + if lua_time_limit is not None: + pulumi.set(__self__, "lua_time_limit", lua_time_limit) + if max_disk_threshold is not None: + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + if maxclients is not None: + pulumi.set(__self__, "maxclients", maxclients) + if maxmemory_policy is not None: + pulumi.set(__self__, "maxmemory_policy", maxmemory_policy) + if maxmemory_samples is not None: + pulumi.set(__self__, "maxmemory_samples", maxmemory_samples) + if metrics_frequency is not None: + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + if metrics_prefix is not None: + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + if min_replicas_max_lag is not None: + pulumi.set(__self__, "min_replicas_max_lag", min_replicas_max_lag) + if monitoring_instance_id is not None: + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + if notify_keyspace_events is not None: + pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events) + if sgw_acl is not None: + pulumi.set(__self__, "sgw_acl", sgw_acl) + if snapshot is not None: + pulumi.set(__self__, "snapshot", snapshot) + if syslogs is not None: + pulumi.set(__self__, "syslogs", syslogs) + if tls_ciphers is not None: + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + if tls_ciphersuites is not None: + pulumi.set(__self__, "tls_ciphersuites", tls_ciphersuites) + if tls_protocols is not None: + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="downAfterMilliseconds") + def down_after_milliseconds(self) -> Optional[builtins.int]: + """ + The number of milliseconds after which the instance is considered down. + """ + return pulumi.get(self, "down_after_milliseconds") + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> Optional[builtins.bool]: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter(name="failoverTimeout") + def failover_timeout(self) -> Optional[builtins.int]: + """ + The failover timeout in milliseconds. + """ + return pulumi.get(self, "failover_timeout") + + @property + @pulumi.getter + def graphite(self) -> Optional[builtins.str]: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="lazyfreeLazyEviction") + def lazyfree_lazy_eviction(self) -> Optional[builtins.str]: + """ + The lazy eviction enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_eviction") + + @property + @pulumi.getter(name="lazyfreeLazyExpire") + def lazyfree_lazy_expire(self) -> Optional[builtins.str]: + """ + The lazy expire enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_expire") + + @property + @pulumi.getter(name="luaTimeLimit") + def lua_time_limit(self) -> Optional[builtins.int]: + """ + The Lua time limit. + """ + return pulumi.get(self, "lua_time_limit") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> Optional[builtins.int]: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter + def maxclients(self) -> Optional[builtins.int]: + """ + The maximum number of clients. + """ + return pulumi.get(self, "maxclients") + + @property + @pulumi.getter(name="maxmemoryPolicy") + def maxmemory_policy(self) -> Optional[builtins.str]: + """ + The policy to handle the maximum memory (volatile-lru, noeviction, etc). + """ + return pulumi.get(self, "maxmemory_policy") + + @property + @pulumi.getter(name="maxmemorySamples") + def maxmemory_samples(self) -> Optional[builtins.int]: + """ + The maximum memory samples. + """ + return pulumi.get(self, "maxmemory_samples") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> Optional[builtins.int]: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> Optional[builtins.str]: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="minReplicasMaxLag") + def min_replicas_max_lag(self) -> Optional[builtins.int]: + """ + The minimum replicas maximum lag. + """ + return pulumi.get(self, "min_replicas_max_lag") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> Optional[builtins.str]: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="notifyKeyspaceEvents") + def notify_keyspace_events(self) -> Optional[builtins.str]: + """ + The notify keyspace events. + """ + return pulumi.get(self, "notify_keyspace_events") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> Optional[builtins.str]: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def snapshot(self) -> Optional[builtins.str]: + """ + The snapshot configuration. + """ + return pulumi.get(self, "snapshot") + + @property + @pulumi.getter + def syslogs(self) -> Optional[Sequence[builtins.str]]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Optional[Sequence[builtins.str]]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsCiphersuites") + def tls_ciphersuites(self) -> Optional[builtins.str]: + """ + TLS cipher suites to use. + """ + return pulumi.get(self, "tls_ciphersuites") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> Optional[builtins.str]: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class SecurityGroupRuleIcmpParameters(dict): + def __init__(__self__, *, + code: builtins.int, + type: builtins.int): + """ + :param builtins.int code: ICMP code. Can be set if the protocol is ICMP. + :param builtins.int type: ICMP type. Can be set if the protocol is ICMP. + """ + pulumi.set(__self__, "code", code) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def code(self) -> builtins.int: + """ + ICMP code. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "code") + + @property + @pulumi.getter + def type(self) -> builtins.int: + """ + ICMP type. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class SecurityGroupRulePortRange(dict): + def __init__(__self__, *, + max: builtins.int, + min: builtins.int): + """ + :param builtins.int max: The maximum port number. Should be greater or equal to the minimum. + :param builtins.int min: The minimum port number. Should be less or equal to the maximum. + """ + pulumi.set(__self__, "max", max) + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> builtins.int: + """ + The maximum port number. Should be greater or equal to the minimum. + """ + return pulumi.get(self, "max") + + @property + @pulumi.getter + def min(self) -> builtins.int: + """ + The minimum port number. Should be less or equal to the maximum. + """ + return pulumi.get(self, "min") + + +@pulumi.output_type +class SecurityGroupRuleProtocol(dict): + def __init__(__self__, *, + name: Optional[builtins.str] = None, + number: Optional[builtins.int] = None): + """ + :param builtins.str name: The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + :param builtins.int number: The protocol number which the rule should match. Either `name` or `number` must be provided. + """ + if name is not None: + pulumi.set(__self__, "name", name) + if number is not None: + pulumi.set(__self__, "number", number) + + @property + @pulumi.getter + def name(self) -> Optional[builtins.str]: + """ + The protocol name which the rule should match. Either `name` or `number` must be provided. Possible values are: `ah`, `dccp`, `egp`, `esp`, `gre`, `icmp`, `igmp`, `ipip`, `ipv6-encap`, `ipv6-frag`, `ipv6-icmp`, `ipv6-nonxt`, `ipv6-opts`, `ipv6-route`, `ospf`, `pgm`, `rsvp`, `sctp`, `tcp`, `udp`, `udplite`, `vrrp`. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def number(self) -> Optional[builtins.int]: + """ + The protocol number which the rule should match. Either `name` or `number` must be provided. + """ + return pulumi.get(self, "number") + + +@pulumi.output_type +class ServerBackupScheduleBackupProperties(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "retentionPeriod": + suggest = "retention_period" + elif key == "volumeIds": + suggest = "volume_ids" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ServerBackupScheduleBackupProperties. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ServerBackupScheduleBackupProperties.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ServerBackupScheduleBackupProperties.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name: builtins.str, + retention_period: builtins.int, + volume_ids: Optional[Sequence[builtins.str]] = None): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "retention_period", retention_period) + if volume_ids is not None: + pulumi.set(__self__, "volume_ids", volume_ids) + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="retentionPeriod") + def retention_period(self) -> builtins.int: + return pulumi.get(self, "retention_period") + + @property + @pulumi.getter(name="volumeIds") + def volume_ids(self) -> Optional[Sequence[builtins.str]]: + return pulumi.get(self, "volume_ids") + + +@pulumi.output_type +class ServerBootVolume(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sourceId": + suggest = "source_id" + elif key == "sourceType": + suggest = "source_type" + elif key == "deleteOnTermination": + suggest = "delete_on_termination" + elif key == "performanceClass": + suggest = "performance_class" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ServerBootVolume. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ServerBootVolume.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ServerBootVolume.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + source_id: builtins.str, + source_type: builtins.str, + delete_on_termination: Optional[builtins.bool] = None, + id: Optional[builtins.str] = None, + performance_class: Optional[builtins.str] = None, + size: Optional[builtins.int] = None): + """ + :param builtins.str source_id: The ID of the source, either image ID or volume ID + :param builtins.str source_type: The type of the source. Supported values are: `volume`, `image`. + :param builtins.bool delete_on_termination: Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + :param builtins.str id: The ID of the boot volume + :param builtins.str performance_class: The performance class of the server. + :param builtins.int size: The size of the boot volume in GB. Must be provided when `source_type` is `image`. + """ + pulumi.set(__self__, "source_id", source_id) + pulumi.set(__self__, "source_type", source_type) + if delete_on_termination is not None: + pulumi.set(__self__, "delete_on_termination", delete_on_termination) + if id is not None: + pulumi.set(__self__, "id", id) + if performance_class is not None: + pulumi.set(__self__, "performance_class", performance_class) + if size is not None: + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="sourceId") + def source_id(self) -> builtins.str: + """ + The ID of the source, either image ID or volume ID + """ + return pulumi.get(self, "source_id") + + @property + @pulumi.getter(name="sourceType") + def source_type(self) -> builtins.str: + """ + The type of the source. Supported values are: `volume`, `image`. + """ + return pulumi.get(self, "source_type") + + @property + @pulumi.getter(name="deleteOnTermination") + def delete_on_termination(self) -> Optional[builtins.bool]: + """ + Delete the volume during the termination of the server. Only allowed when `source_type` is `image`. + """ + return pulumi.get(self, "delete_on_termination") + + @property + @pulumi.getter + def id(self) -> Optional[builtins.str]: + """ + The ID of the boot volume + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> Optional[builtins.str]: + """ + The performance class of the server. + """ + return pulumi.get(self, "performance_class") + + @property + @pulumi.getter + def size(self) -> Optional[builtins.int]: + """ + The size of the boot volume in GB. Must be provided when `source_type` is `image`. + """ + return pulumi.get(self, "size") + + +@pulumi.output_type +class SkeClusterExtensions(dict): + def __init__(__self__, *, + acl: Optional['outputs.SkeClusterExtensionsAcl'] = None, + argus: Optional['outputs.SkeClusterExtensionsArgus'] = None, + dns: Optional['outputs.SkeClusterExtensionsDns'] = None): + """ + :param 'SkeClusterExtensionsAclArgs' acl: Cluster access control configuration. + :param 'SkeClusterExtensionsArgusArgs' argus: A single argus block as defined below. + :param 'SkeClusterExtensionsDnsArgs' dns: DNS extension configuration + """ + if acl is not None: + pulumi.set(__self__, "acl", acl) + if argus is not None: + pulumi.set(__self__, "argus", argus) + if dns is not None: + pulumi.set(__self__, "dns", dns) + + @property + @pulumi.getter + def acl(self) -> Optional['outputs.SkeClusterExtensionsAcl']: + """ + Cluster access control configuration. + """ + return pulumi.get(self, "acl") + + @property + @pulumi.getter + def argus(self) -> Optional['outputs.SkeClusterExtensionsArgus']: + """ + A single argus block as defined below. + """ + return pulumi.get(self, "argus") + + @property + @pulumi.getter + def dns(self) -> Optional['outputs.SkeClusterExtensionsDns']: + """ + DNS extension configuration + """ + return pulumi.get(self, "dns") + + +@pulumi.output_type +class SkeClusterExtensionsAcl(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "allowedCidrs": + suggest = "allowed_cidrs" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SkeClusterExtensionsAcl. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SkeClusterExtensionsAcl.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SkeClusterExtensionsAcl.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allowed_cidrs: Sequence[builtins.str], + enabled: builtins.bool): + """ + :param Sequence[builtins.str] allowed_cidrs: Specify a list of CIDRs to whitelist. + :param builtins.bool enabled: Is ACL enabled? + """ + pulumi.set(__self__, "allowed_cidrs", allowed_cidrs) + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="allowedCidrs") + def allowed_cidrs(self) -> Sequence[builtins.str]: + """ + Specify a list of CIDRs to whitelist. + """ + return pulumi.get(self, "allowed_cidrs") + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is ACL enabled? + """ + return pulumi.get(self, "enabled") + + +@pulumi.output_type +class SkeClusterExtensionsArgus(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "argusInstanceId": + suggest = "argus_instance_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SkeClusterExtensionsArgus. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SkeClusterExtensionsArgus.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SkeClusterExtensionsArgus.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + enabled: builtins.bool, + argus_instance_id: Optional[builtins.str] = None): + """ + :param builtins.bool enabled: Flag to enable/disable Argus extensions. + :param builtins.str argus_instance_id: Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + """ + pulumi.set(__self__, "enabled", enabled) + if argus_instance_id is not None: + pulumi.set(__self__, "argus_instance_id", argus_instance_id) + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Flag to enable/disable Argus extensions. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter(name="argusInstanceId") + def argus_instance_id(self) -> Optional[builtins.str]: + """ + Argus instance ID to choose which Argus instance is used. Required when enabled is set to `true`. + """ + return pulumi.get(self, "argus_instance_id") + + +@pulumi.output_type +class SkeClusterExtensionsDns(dict): + def __init__(__self__, *, + enabled: builtins.bool, + zones: Optional[Sequence[builtins.str]] = None): + """ + :param builtins.bool enabled: Flag to enable/disable DNS extensions + :param Sequence[builtins.str] zones: Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + pulumi.set(__self__, "enabled", enabled) + if zones is not None: + pulumi.set(__self__, "zones", zones) + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Flag to enable/disable DNS extensions + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def zones(self) -> Optional[Sequence[builtins.str]]: + """ + Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + return pulumi.get(self, "zones") + + +@pulumi.output_type +class SkeClusterHibernation(dict): + def __init__(__self__, *, + end: builtins.str, + start: builtins.str, + timezone: Optional[builtins.str] = None): + """ + :param builtins.str end: End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + :param builtins.str start: Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + :param builtins.str timezone: Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + """ + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + if timezone is not None: + pulumi.set(__self__, "timezone", timezone) + + @property + @pulumi.getter + def end(self) -> builtins.str: + """ + End time of hibernation in crontab syntax. E.g. `0 8 * * *` for waking up the cluster at 8am. + """ + return pulumi.get(self, "end") + + @property + @pulumi.getter + def start(self) -> builtins.str: + """ + Start time of cluster hibernation in crontab syntax. E.g. `0 18 * * *` for starting everyday at 6pm. + """ + return pulumi.get(self, "start") + + @property + @pulumi.getter + def timezone(self) -> Optional[builtins.str]: + """ + Timezone name corresponding to a file in the IANA Time Zone database. i.e. `Europe/Berlin`. + """ + return pulumi.get(self, "timezone") + + +@pulumi.output_type +class SkeClusterMaintenance(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "enableKubernetesVersionUpdates": + suggest = "enable_kubernetes_version_updates" + elif key == "enableMachineImageVersionUpdates": + suggest = "enable_machine_image_version_updates" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SkeClusterMaintenance. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SkeClusterMaintenance.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SkeClusterMaintenance.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + end: builtins.str, + start: builtins.str, + enable_kubernetes_version_updates: Optional[builtins.bool] = None, + enable_machine_image_version_updates: Optional[builtins.bool] = None): + """ + :param builtins.str end: Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + :param builtins.str start: Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + :param builtins.bool enable_kubernetes_version_updates: Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param builtins.bool enable_machine_image_version_updates: Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + if enable_kubernetes_version_updates is not None: + pulumi.set(__self__, "enable_kubernetes_version_updates", enable_kubernetes_version_updates) + if enable_machine_image_version_updates is not None: + pulumi.set(__self__, "enable_machine_image_version_updates", enable_machine_image_version_updates) + + @property + @pulumi.getter + def end(self) -> builtins.str: + """ + Time for maintenance window end. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + return pulumi.get(self, "end") + + @property + @pulumi.getter + def start(self) -> builtins.str: + """ + Time for maintenance window start. E.g. `01:23:45Z`, `05:00:00+02:00`. + """ + return pulumi.get(self, "start") + + @property + @pulumi.getter(name="enableKubernetesVersionUpdates") + def enable_kubernetes_version_updates(self) -> Optional[builtins.bool]: + """ + Flag to enable/disable auto-updates of the Kubernetes version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "enable_kubernetes_version_updates") + + @property + @pulumi.getter(name="enableMachineImageVersionUpdates") + def enable_machine_image_version_updates(self) -> Optional[builtins.bool]: + """ + Flag to enable/disable auto-updates of the OS image version. Defaults to `true`. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "enable_machine_image_version_updates") + + +@pulumi.output_type +class SkeClusterNetwork(dict): + def __init__(__self__, *, + id: Optional[builtins.str] = None): + """ + :param builtins.str id: ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def id(self) -> Optional[builtins.str]: + """ + ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + return pulumi.get(self, "id") + + +@pulumi.output_type +class SkeClusterNodePool(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "availabilityZones": + suggest = "availability_zones" + elif key == "machineType": + suggest = "machine_type" + elif key == "allowSystemComponents": + suggest = "allow_system_components" + elif key == "maxSurge": + suggest = "max_surge" + elif key == "maxUnavailable": + suggest = "max_unavailable" + elif key == "osName": + suggest = "os_name" + elif key == "osVersion": + suggest = "os_version" + elif key == "osVersionMin": + suggest = "os_version_min" + elif key == "osVersionUsed": + suggest = "os_version_used" + elif key == "volumeSize": + suggest = "volume_size" + elif key == "volumeType": + suggest = "volume_type" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SkeClusterNodePool. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SkeClusterNodePool.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SkeClusterNodePool.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + availability_zones: Sequence[builtins.str], + machine_type: builtins.str, + maximum: builtins.int, + minimum: builtins.int, + name: builtins.str, + allow_system_components: Optional[builtins.bool] = None, + cri: Optional[builtins.str] = None, + labels: Optional[Mapping[str, builtins.str]] = None, + max_surge: Optional[builtins.int] = None, + max_unavailable: Optional[builtins.int] = None, + os_name: Optional[builtins.str] = None, + os_version: Optional[builtins.str] = None, + os_version_min: Optional[builtins.str] = None, + os_version_used: Optional[builtins.str] = None, + taints: Optional[Sequence['outputs.SkeClusterNodePoolTaint']] = None, + volume_size: Optional[builtins.int] = None, + volume_type: Optional[builtins.str] = None): + """ + :param Sequence[builtins.str] availability_zones: Specify a list of availability zones. E.g. `eu01-m` + :param builtins.str machine_type: The machine type. + :param builtins.int maximum: Maximum number of nodes in the pool. + :param builtins.int minimum: Minimum number of nodes in the pool. + :param builtins.str name: Specifies the name of the node pool. + :param builtins.bool allow_system_components: Allow system components to run on this node pool. + :param builtins.str cri: Specifies the container runtime. Defaults to `containerd` + :param Mapping[str, builtins.str] labels: Labels to add to each node. + :param builtins.int max_surge: Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + :param builtins.int max_unavailable: Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + :param builtins.str os_name: The name of the OS image. Defaults to `flatcar`. + :param builtins.str os_version: This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + :param builtins.str os_version_min: The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + :param builtins.str os_version_used: Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param Sequence['SkeClusterNodePoolTaintArgs'] taints: Specifies a taint list as defined below. + :param builtins.int volume_size: The volume size in GB. Defaults to `20` + :param builtins.str volume_type: Specifies the volume type. Defaults to `storage_premium_perf1`. + """ + pulumi.set(__self__, "availability_zones", availability_zones) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "maximum", maximum) + pulumi.set(__self__, "minimum", minimum) + pulumi.set(__self__, "name", name) + if allow_system_components is not None: + pulumi.set(__self__, "allow_system_components", allow_system_components) + if cri is not None: + pulumi.set(__self__, "cri", cri) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if max_surge is not None: + pulumi.set(__self__, "max_surge", max_surge) + if max_unavailable is not None: + pulumi.set(__self__, "max_unavailable", max_unavailable) + if os_name is not None: + pulumi.set(__self__, "os_name", os_name) + if os_version is not None: + pulumi.set(__self__, "os_version", os_version) + if os_version_min is not None: + pulumi.set(__self__, "os_version_min", os_version_min) + if os_version_used is not None: + pulumi.set(__self__, "os_version_used", os_version_used) + if taints is not None: + pulumi.set(__self__, "taints", taints) + if volume_size is not None: + pulumi.set(__self__, "volume_size", volume_size) + if volume_type is not None: + pulumi.set(__self__, "volume_type", volume_type) + + @property + @pulumi.getter(name="availabilityZones") + def availability_zones(self) -> Sequence[builtins.str]: + """ + Specify a list of availability zones. E.g. `eu01-m` + """ + return pulumi.get(self, "availability_zones") + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> builtins.str: + """ + The machine type. + """ + return pulumi.get(self, "machine_type") + + @property + @pulumi.getter + def maximum(self) -> builtins.int: + """ + Maximum number of nodes in the pool. + """ + return pulumi.get(self, "maximum") + + @property + @pulumi.getter + def minimum(self) -> builtins.int: + """ + Minimum number of nodes in the pool. + """ + return pulumi.get(self, "minimum") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Specifies the name of the node pool. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="allowSystemComponents") + def allow_system_components(self) -> Optional[builtins.bool]: + """ + Allow system components to run on this node pool. + """ + return pulumi.get(self, "allow_system_components") + + @property + @pulumi.getter + def cri(self) -> Optional[builtins.str]: + """ + Specifies the container runtime. Defaults to `containerd` + """ + return pulumi.get(self, "cri") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, builtins.str]]: + """ + Labels to add to each node. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="maxSurge") + def max_surge(self) -> Optional[builtins.int]: + """ + Maximum number of additional VMs that are created during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + return pulumi.get(self, "max_surge") + + @property + @pulumi.getter(name="maxUnavailable") + def max_unavailable(self) -> Optional[builtins.int]: + """ + Maximum number of VMs that that can be unavailable during an update. If set (larger than 0), then it must be at least the amount of zones configured for the nodepool. The `max_surge` and `max_unavailable` fields cannot both be unset at the same time. + """ + return pulumi.get(self, "max_unavailable") + + @property + @pulumi.getter(name="osName") + def os_name(self) -> Optional[builtins.str]: + """ + The name of the OS image. Defaults to `flatcar`. + """ + return pulumi.get(self, "os_name") + + @property + @pulumi.getter(name="osVersion") + @_utilities.deprecated("""Use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. Setting a specific OS image version will cause errors during minor OS upgrades due to forced updates.""") + def os_version(self) -> Optional[builtins.str]: + """ + This field is deprecated, use `os_version_min` to configure the version and `os_version_used` to get the currently used version instead. + """ + return pulumi.get(self, "os_version") + + @property + @pulumi.getter(name="osVersionMin") + def os_version_min(self) -> Optional[builtins.str]: + """ + The minimum OS image version. This field will be used to set the minimum OS image version on creation/update of the cluster. If unset, the latest supported OS image version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + """ + return pulumi.get(self, "os_version_min") + + @property + @pulumi.getter(name="osVersionUsed") + def os_version_used(self) -> Optional[builtins.str]: + """ + Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "os_version_used") + + @property + @pulumi.getter + def taints(self) -> Optional[Sequence['outputs.SkeClusterNodePoolTaint']]: + """ + Specifies a taint list as defined below. + """ + return pulumi.get(self, "taints") + + @property + @pulumi.getter(name="volumeSize") + def volume_size(self) -> Optional[builtins.int]: + """ + The volume size in GB. Defaults to `20` + """ + return pulumi.get(self, "volume_size") + + @property + @pulumi.getter(name="volumeType") + def volume_type(self) -> Optional[builtins.str]: + """ + Specifies the volume type. Defaults to `storage_premium_perf1`. + """ + return pulumi.get(self, "volume_type") + + +@pulumi.output_type +class SkeClusterNodePoolTaint(dict): + def __init__(__self__, *, + effect: builtins.str, + key: builtins.str, + value: Optional[builtins.str] = None): + """ + :param builtins.str effect: The taint effect. E.g `PreferNoSchedule`. + :param builtins.str key: Taint key to be applied to a node. + :param builtins.str value: Taint value corresponding to the taint key. + """ + pulumi.set(__self__, "effect", effect) + pulumi.set(__self__, "key", key) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def effect(self) -> builtins.str: + """ + The taint effect. E.g `PreferNoSchedule`. + """ + return pulumi.get(self, "effect") + + @property + @pulumi.getter + def key(self) -> builtins.str: + """ + Taint key to be applied to a node. + """ + return pulumi.get(self, "key") + + @property + @pulumi.getter + def value(self) -> Optional[builtins.str]: + """ + Taint value corresponding to the taint key. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class SqlserverflexInstanceFlavor(dict): + def __init__(__self__, *, + cpu: builtins.int, + ram: builtins.int, + description: Optional[builtins.str] = None, + id: Optional[builtins.str] = None): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "ram", ram) + if description is not None: + pulumi.set(__self__, "description", description) + if id is not None: + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + @property + @pulumi.getter + def description(self) -> Optional[builtins.str]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> Optional[builtins.str]: + return pulumi.get(self, "id") + + +@pulumi.output_type +class SqlserverflexInstanceOptions(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "retentionDays": + suggest = "retention_days" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SqlserverflexInstanceOptions. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SqlserverflexInstanceOptions.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SqlserverflexInstanceOptions.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + edition: Optional[builtins.str] = None, + retention_days: Optional[builtins.int] = None): + if edition is not None: + pulumi.set(__self__, "edition", edition) + if retention_days is not None: + pulumi.set(__self__, "retention_days", retention_days) + + @property + @pulumi.getter + def edition(self) -> Optional[builtins.str]: + return pulumi.get(self, "edition") + + @property + @pulumi.getter(name="retentionDays") + def retention_days(self) -> Optional[builtins.int]: + return pulumi.get(self, "retention_days") + + +@pulumi.output_type +class SqlserverflexInstanceStorage(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "class": + suggest = "class_" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SqlserverflexInstanceStorage. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SqlserverflexInstanceStorage.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SqlserverflexInstanceStorage.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + class_: Optional[builtins.str] = None, + size: Optional[builtins.int] = None): + if class_ is not None: + pulumi.set(__self__, "class_", class_) + if size is not None: + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> Optional[builtins.str]: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> Optional[builtins.int]: + return pulumi.get(self, "size") + + +@pulumi.output_type +class VolumeSource(dict): + def __init__(__self__, *, + id: builtins.str, + type: builtins.str): + """ + :param builtins.str id: The ID of the source, e.g. image ID + :param builtins.str type: The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def id(self) -> builtins.str: + """ + The ID of the source, e.g. image ID + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetCdnDistributionConfigResult(dict): + def __init__(__self__, *, + backend: 'outputs.GetCdnDistributionConfigBackendResult', + regions: Sequence[builtins.str]): + """ + :param 'GetCdnDistributionConfigBackendArgs' backend: The configured backend for the distribution + :param Sequence[builtins.str] regions: The configured regions where content will be hosted + """ + pulumi.set(__self__, "backend", backend) + pulumi.set(__self__, "regions", regions) + + @property + @pulumi.getter + def backend(self) -> 'outputs.GetCdnDistributionConfigBackendResult': + """ + The configured backend for the distribution + """ + return pulumi.get(self, "backend") + + @property + @pulumi.getter + def regions(self) -> Sequence[builtins.str]: + """ + The configured regions where content will be hosted + """ + return pulumi.get(self, "regions") + + +@pulumi.output_type +class GetCdnDistributionConfigBackendResult(dict): + def __init__(__self__, *, + origin_request_headers: Mapping[str, builtins.str], + origin_url: builtins.str, + type: builtins.str): + """ + :param Mapping[str, builtins.str] origin_request_headers: The configured origin request headers for the backend + :param builtins.str origin_url: The configured backend type for the distribution + :param builtins.str type: The configured backend type. Supported values are: `http`. + """ + pulumi.set(__self__, "origin_request_headers", origin_request_headers) + pulumi.set(__self__, "origin_url", origin_url) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter(name="originRequestHeaders") + def origin_request_headers(self) -> Mapping[str, builtins.str]: + """ + The configured origin request headers for the backend + """ + return pulumi.get(self, "origin_request_headers") + + @property + @pulumi.getter(name="originUrl") + def origin_url(self) -> builtins.str: + """ + The configured backend type for the distribution + """ + return pulumi.get(self, "origin_url") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The configured backend type. Supported values are: `http`. + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetCdnDistributionDomainResult(dict): + def __init__(__self__, *, + errors: Sequence[builtins.str], + name: builtins.str, + status: builtins.str, + type: builtins.str): + """ + :param Sequence[builtins.str] errors: List of domain errors + :param builtins.str name: The name of the domain + :param builtins.str status: The status of the domain + :param builtins.str type: The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + pulumi.set(__self__, "errors", errors) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "status", status) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def errors(self) -> Sequence[builtins.str]: + """ + List of domain errors + """ + return pulumi.get(self, "errors") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The name of the domain + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def status(self) -> builtins.str: + """ + The status of the domain + """ + return pulumi.get(self, "status") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The type of the domain. Each distribution has one domain of type "managed", and domains of type "custom" may be additionally created by the user + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetImageChecksumResult(dict): + def __init__(__self__, *, + algorithm: builtins.str, + digest: builtins.str): + """ + :param builtins.str algorithm: Algorithm for the checksum of the image data. + :param builtins.str digest: Hexdigest of the checksum of the image data. + """ + pulumi.set(__self__, "algorithm", algorithm) + pulumi.set(__self__, "digest", digest) + + @property + @pulumi.getter + def algorithm(self) -> builtins.str: + """ + Algorithm for the checksum of the image data. + """ + return pulumi.get(self, "algorithm") + + @property + @pulumi.getter + def digest(self) -> builtins.str: + """ + Hexdigest of the checksum of the image data. + """ + return pulumi.get(self, "digest") + + +@pulumi.output_type +class GetImageConfigResult(dict): + def __init__(__self__, *, + boot_menu: builtins.bool, + cdrom_bus: builtins.str, + disk_bus: builtins.str, + nic_model: builtins.str, + operating_system: builtins.str, + operating_system_distro: builtins.str, + operating_system_version: builtins.str, + rescue_bus: builtins.str, + rescue_device: builtins.str, + secure_boot: builtins.bool, + uefi: builtins.bool, + video_model: builtins.str, + virtio_scsi: builtins.bool): + """ + :param builtins.bool boot_menu: Enables the BIOS bootmenu. + :param builtins.str cdrom_bus: Sets CDROM bus controller type. + :param builtins.str disk_bus: Sets Disk bus controller type. + :param builtins.str nic_model: Sets virtual network interface model. + :param builtins.str operating_system: Enables operating system specific optimizations. + :param builtins.str operating_system_distro: Operating system distribution. + :param builtins.str operating_system_version: Version of the operating system. + :param builtins.str rescue_bus: Sets the device bus when the image is used as a rescue image. + :param builtins.str rescue_device: Sets the device when the image is used as a rescue image. + :param builtins.bool secure_boot: Enables Secure Boot. + :param builtins.bool uefi: Enables UEFI boot. + :param builtins.str video_model: Sets Graphic device model. + :param builtins.bool virtio_scsi: Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + pulumi.set(__self__, "boot_menu", boot_menu) + pulumi.set(__self__, "cdrom_bus", cdrom_bus) + pulumi.set(__self__, "disk_bus", disk_bus) + pulumi.set(__self__, "nic_model", nic_model) + pulumi.set(__self__, "operating_system", operating_system) + pulumi.set(__self__, "operating_system_distro", operating_system_distro) + pulumi.set(__self__, "operating_system_version", operating_system_version) + pulumi.set(__self__, "rescue_bus", rescue_bus) + pulumi.set(__self__, "rescue_device", rescue_device) + pulumi.set(__self__, "secure_boot", secure_boot) + pulumi.set(__self__, "uefi", uefi) + pulumi.set(__self__, "video_model", video_model) + pulumi.set(__self__, "virtio_scsi", virtio_scsi) + + @property + @pulumi.getter(name="bootMenu") + def boot_menu(self) -> builtins.bool: + """ + Enables the BIOS bootmenu. + """ + return pulumi.get(self, "boot_menu") + + @property + @pulumi.getter(name="cdromBus") + def cdrom_bus(self) -> builtins.str: + """ + Sets CDROM bus controller type. + """ + return pulumi.get(self, "cdrom_bus") + + @property + @pulumi.getter(name="diskBus") + def disk_bus(self) -> builtins.str: + """ + Sets Disk bus controller type. + """ + return pulumi.get(self, "disk_bus") + + @property + @pulumi.getter(name="nicModel") + def nic_model(self) -> builtins.str: + """ + Sets virtual network interface model. + """ + return pulumi.get(self, "nic_model") + + @property + @pulumi.getter(name="operatingSystem") + def operating_system(self) -> builtins.str: + """ + Enables operating system specific optimizations. + """ + return pulumi.get(self, "operating_system") + + @property + @pulumi.getter(name="operatingSystemDistro") + def operating_system_distro(self) -> builtins.str: + """ + Operating system distribution. + """ + return pulumi.get(self, "operating_system_distro") + + @property + @pulumi.getter(name="operatingSystemVersion") + def operating_system_version(self) -> builtins.str: + """ + Version of the operating system. + """ + return pulumi.get(self, "operating_system_version") + + @property + @pulumi.getter(name="rescueBus") + def rescue_bus(self) -> builtins.str: + """ + Sets the device bus when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_bus") + + @property + @pulumi.getter(name="rescueDevice") + def rescue_device(self) -> builtins.str: + """ + Sets the device when the image is used as a rescue image. + """ + return pulumi.get(self, "rescue_device") + + @property + @pulumi.getter(name="secureBoot") + def secure_boot(self) -> builtins.bool: + """ + Enables Secure Boot. + """ + return pulumi.get(self, "secure_boot") + + @property + @pulumi.getter + def uefi(self) -> builtins.bool: + """ + Enables UEFI boot. + """ + return pulumi.get(self, "uefi") + + @property + @pulumi.getter(name="videoModel") + def video_model(self) -> builtins.str: + """ + Sets Graphic device model. + """ + return pulumi.get(self, "video_model") + + @property + @pulumi.getter(name="virtioScsi") + def virtio_scsi(self) -> builtins.bool: + """ + Enables the use of VirtIO SCSI to provide block device access. By default instances use VirtIO Block. + """ + return pulumi.get(self, "virtio_scsi") + + +@pulumi.output_type +class GetLoadbalancerListenerResult(dict): + def __init__(__self__, *, + display_name: builtins.str, + port: builtins.int, + protocol: builtins.str, + target_pool: builtins.str, + server_name_indicators: Optional[Sequence['outputs.GetLoadbalancerListenerServerNameIndicatorResult']] = None): + """ + :param builtins.int port: Port number where we listen for traffic. + :param builtins.str protocol: Protocol is the highest network protocol we understand to load balance. + :param builtins.str target_pool: Reference target pool by target pool name. + :param Sequence['GetLoadbalancerListenerServerNameIndicatorArgs'] server_name_indicators: A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + pulumi.set(__self__, "display_name", display_name) + pulumi.set(__self__, "port", port) + pulumi.set(__self__, "protocol", protocol) + pulumi.set(__self__, "target_pool", target_pool) + if server_name_indicators is not None: + pulumi.set(__self__, "server_name_indicators", server_name_indicators) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> builtins.str: + return pulumi.get(self, "display_name") + + @property + @pulumi.getter + def port(self) -> builtins.int: + """ + Port number where we listen for traffic. + """ + return pulumi.get(self, "port") + + @property + @pulumi.getter + def protocol(self) -> builtins.str: + """ + Protocol is the highest network protocol we understand to load balance. + """ + return pulumi.get(self, "protocol") + + @property + @pulumi.getter(name="targetPool") + def target_pool(self) -> builtins.str: + """ + Reference target pool by target pool name. + """ + return pulumi.get(self, "target_pool") + + @property + @pulumi.getter(name="serverNameIndicators") + def server_name_indicators(self) -> Optional[Sequence['outputs.GetLoadbalancerListenerServerNameIndicatorResult']]: + """ + A list of domain names to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "server_name_indicators") + + +@pulumi.output_type +class GetLoadbalancerListenerServerNameIndicatorResult(dict): + def __init__(__self__, *, + name: Optional[builtins.str] = None): + """ + :param builtins.str name: A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter + def name(self) -> Optional[builtins.str]: + """ + A domain name to match in order to pass TLS traffic to the target pool in the current listener + """ + return pulumi.get(self, "name") + + +@pulumi.output_type +class GetLoadbalancerNetworkResult(dict): + def __init__(__self__, *, + network_id: builtins.str, + role: builtins.str): + """ + :param builtins.str network_id: Openstack network ID. + :param builtins.str role: The role defines how the load balancer is using the network. + """ + pulumi.set(__self__, "network_id", network_id) + pulumi.set(__self__, "role", role) + + @property + @pulumi.getter(name="networkId") + def network_id(self) -> builtins.str: + """ + Openstack network ID. + """ + return pulumi.get(self, "network_id") + + @property + @pulumi.getter + def role(self) -> builtins.str: + """ + The role defines how the load balancer is using the network. + """ + return pulumi.get(self, "role") + + +@pulumi.output_type +class GetLoadbalancerOptionsResult(dict): + def __init__(__self__, *, + acls: Sequence[builtins.str], + observability: 'outputs.GetLoadbalancerOptionsObservabilityResult', + private_network_only: builtins.bool): + """ + :param Sequence[builtins.str] acls: Load Balancer is accessible only from an IP address in this range. + :param 'GetLoadbalancerOptionsObservabilityArgs' observability: We offer Load Balancer metrics observability via ARGUS or external solutions. + :param builtins.bool private_network_only: If true, Load Balancer is accessible only via a private network IP address. + """ + pulumi.set(__self__, "acls", acls) + pulumi.set(__self__, "observability", observability) + pulumi.set(__self__, "private_network_only", private_network_only) + + @property + @pulumi.getter + def acls(self) -> Sequence[builtins.str]: + """ + Load Balancer is accessible only from an IP address in this range. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter + def observability(self) -> 'outputs.GetLoadbalancerOptionsObservabilityResult': + """ + We offer Load Balancer metrics observability via ARGUS or external solutions. + """ + return pulumi.get(self, "observability") + + @property + @pulumi.getter(name="privateNetworkOnly") + def private_network_only(self) -> builtins.bool: + """ + If true, Load Balancer is accessible only via a private network IP address. + """ + return pulumi.get(self, "private_network_only") + + +@pulumi.output_type +class GetLoadbalancerOptionsObservabilityResult(dict): + def __init__(__self__, *, + logs: 'outputs.GetLoadbalancerOptionsObservabilityLogsResult', + metrics: 'outputs.GetLoadbalancerOptionsObservabilityMetricsResult'): + """ + :param 'GetLoadbalancerOptionsObservabilityLogsArgs' logs: Observability logs configuration. + :param 'GetLoadbalancerOptionsObservabilityMetricsArgs' metrics: Observability metrics configuration. + """ + pulumi.set(__self__, "logs", logs) + pulumi.set(__self__, "metrics", metrics) + + @property + @pulumi.getter + def logs(self) -> 'outputs.GetLoadbalancerOptionsObservabilityLogsResult': + """ + Observability logs configuration. + """ + return pulumi.get(self, "logs") + + @property + @pulumi.getter + def metrics(self) -> 'outputs.GetLoadbalancerOptionsObservabilityMetricsResult': + """ + Observability metrics configuration. + """ + return pulumi.get(self, "metrics") + + +@pulumi.output_type +class GetLoadbalancerOptionsObservabilityLogsResult(dict): + def __init__(__self__, *, + credentials_ref: builtins.str, + push_url: builtins.str): + """ + :param builtins.str credentials_ref: Credentials reference for logs. + :param builtins.str push_url: Credentials reference for logs. + """ + pulumi.set(__self__, "credentials_ref", credentials_ref) + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> builtins.str: + """ + Credentials reference for logs. + """ + return pulumi.get(self, "credentials_ref") + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> builtins.str: + """ + Credentials reference for logs. + """ + return pulumi.get(self, "push_url") + + +@pulumi.output_type +class GetLoadbalancerOptionsObservabilityMetricsResult(dict): + def __init__(__self__, *, + credentials_ref: builtins.str, + push_url: builtins.str): + """ + :param builtins.str credentials_ref: Credentials reference for metrics. + :param builtins.str push_url: Credentials reference for metrics. + """ + pulumi.set(__self__, "credentials_ref", credentials_ref) + pulumi.set(__self__, "push_url", push_url) + + @property + @pulumi.getter(name="credentialsRef") + def credentials_ref(self) -> builtins.str: + """ + Credentials reference for metrics. + """ + return pulumi.get(self, "credentials_ref") + + @property + @pulumi.getter(name="pushUrl") + def push_url(self) -> builtins.str: + """ + Credentials reference for metrics. + """ + return pulumi.get(self, "push_url") + + +@pulumi.output_type +class GetLoadbalancerTargetPoolResult(dict): + def __init__(__self__, *, + active_health_check: 'outputs.GetLoadbalancerTargetPoolActiveHealthCheckResult', + name: builtins.str, + target_port: builtins.int, + targets: Sequence['outputs.GetLoadbalancerTargetPoolTargetResult'], + session_persistence: Optional['outputs.GetLoadbalancerTargetPoolSessionPersistenceResult'] = None): + """ + :param builtins.str name: Target pool name. + :param builtins.int target_port: Identical port number where each target listens for traffic. + :param Sequence['GetLoadbalancerTargetPoolTargetArgs'] targets: List of all targets which will be used in the pool. Limited to 1000. + :param 'GetLoadbalancerTargetPoolSessionPersistenceArgs' session_persistence: Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + pulumi.set(__self__, "active_health_check", active_health_check) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "target_port", target_port) + pulumi.set(__self__, "targets", targets) + if session_persistence is not None: + pulumi.set(__self__, "session_persistence", session_persistence) + + @property + @pulumi.getter(name="activeHealthCheck") + def active_health_check(self) -> 'outputs.GetLoadbalancerTargetPoolActiveHealthCheckResult': + return pulumi.get(self, "active_health_check") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Target pool name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="targetPort") + def target_port(self) -> builtins.int: + """ + Identical port number where each target listens for traffic. + """ + return pulumi.get(self, "target_port") + + @property + @pulumi.getter + def targets(self) -> Sequence['outputs.GetLoadbalancerTargetPoolTargetResult']: + """ + List of all targets which will be used in the pool. Limited to 1000. + """ + return pulumi.get(self, "targets") + + @property + @pulumi.getter(name="sessionPersistence") + def session_persistence(self) -> Optional['outputs.GetLoadbalancerTargetPoolSessionPersistenceResult']: + """ + Here you can setup various session persistence options, so far only "`use_source_ip_address`" is supported. + """ + return pulumi.get(self, "session_persistence") + + +@pulumi.output_type +class GetLoadbalancerTargetPoolActiveHealthCheckResult(dict): + def __init__(__self__, *, + healthy_threshold: builtins.int, + interval: builtins.str, + interval_jitter: builtins.str, + timeout: builtins.str, + unhealthy_threshold: builtins.int): + """ + :param builtins.int healthy_threshold: Healthy threshold of the health checking. + :param builtins.str interval: Interval duration of health checking in seconds. + :param builtins.str interval_jitter: Interval duration threshold of the health checking in seconds. + :param builtins.str timeout: Active health checking timeout duration in seconds. + :param builtins.int unhealthy_threshold: Unhealthy threshold of the health checking. + """ + pulumi.set(__self__, "healthy_threshold", healthy_threshold) + pulumi.set(__self__, "interval", interval) + pulumi.set(__self__, "interval_jitter", interval_jitter) + pulumi.set(__self__, "timeout", timeout) + pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold) + + @property + @pulumi.getter(name="healthyThreshold") + def healthy_threshold(self) -> builtins.int: + """ + Healthy threshold of the health checking. + """ + return pulumi.get(self, "healthy_threshold") + + @property + @pulumi.getter + def interval(self) -> builtins.str: + """ + Interval duration of health checking in seconds. + """ + return pulumi.get(self, "interval") + + @property + @pulumi.getter(name="intervalJitter") + def interval_jitter(self) -> builtins.str: + """ + Interval duration threshold of the health checking in seconds. + """ + return pulumi.get(self, "interval_jitter") + + @property + @pulumi.getter + def timeout(self) -> builtins.str: + """ + Active health checking timeout duration in seconds. + """ + return pulumi.get(self, "timeout") + + @property + @pulumi.getter(name="unhealthyThreshold") + def unhealthy_threshold(self) -> builtins.int: + """ + Unhealthy threshold of the health checking. + """ + return pulumi.get(self, "unhealthy_threshold") + + +@pulumi.output_type +class GetLoadbalancerTargetPoolSessionPersistenceResult(dict): + def __init__(__self__, *, + use_source_ip_address: Optional[builtins.bool] = None): + """ + :param builtins.bool use_source_ip_address: If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + if use_source_ip_address is not None: + pulumi.set(__self__, "use_source_ip_address", use_source_ip_address) + + @property + @pulumi.getter(name="useSourceIpAddress") + def use_source_ip_address(self) -> Optional[builtins.bool]: + """ + If true then all connections from one source IP address are redirected to the same target. This setting changes the load balancing algorithm to Maglev. + """ + return pulumi.get(self, "use_source_ip_address") + + +@pulumi.output_type +class GetLoadbalancerTargetPoolTargetResult(dict): + def __init__(__self__, *, + display_name: builtins.str, + ip: builtins.str): + """ + :param builtins.str display_name: Target display name + :param builtins.str ip: Target IP + """ + pulumi.set(__self__, "display_name", display_name) + pulumi.set(__self__, "ip", ip) + + @property + @pulumi.getter(name="displayName") + def display_name(self) -> builtins.str: + """ + Target display name + """ + return pulumi.get(self, "display_name") + + @property + @pulumi.getter + def ip(self) -> builtins.str: + """ + Target IP + """ + return pulumi.get(self, "ip") + + +@pulumi.output_type +class GetLogmeInstanceParametersResult(dict): + def __init__(__self__, *, + enable_monitoring: builtins.bool, + fluentd_tcp: builtins.int, + fluentd_tls: builtins.int, + fluentd_tls_ciphers: builtins.str, + fluentd_tls_max_version: builtins.str, + fluentd_tls_min_version: builtins.str, + fluentd_tls_version: builtins.str, + fluentd_udp: builtins.int, + graphite: builtins.str, + ism_deletion_after: builtins.str, + ism_jitter: builtins.float, + ism_job_interval: builtins.int, + java_heapspace: builtins.int, + java_maxmetaspace: builtins.int, + max_disk_threshold: builtins.int, + metrics_frequency: builtins.int, + metrics_prefix: builtins.str, + monitoring_instance_id: builtins.str, + opensearch_tls_ciphers: Sequence[builtins.str], + opensearch_tls_protocols: Sequence[builtins.str], + sgw_acl: builtins.str, + syslogs: Sequence[builtins.str]): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param builtins.str ism_deletion_after: Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + :param builtins.int ism_job_interval: Jitter of the execution time. + :param builtins.int java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param builtins.int java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + """ + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + pulumi.set(__self__, "fluentd_tcp", fluentd_tcp) + pulumi.set(__self__, "fluentd_tls", fluentd_tls) + pulumi.set(__self__, "fluentd_tls_ciphers", fluentd_tls_ciphers) + pulumi.set(__self__, "fluentd_tls_max_version", fluentd_tls_max_version) + pulumi.set(__self__, "fluentd_tls_min_version", fluentd_tls_min_version) + pulumi.set(__self__, "fluentd_tls_version", fluentd_tls_version) + pulumi.set(__self__, "fluentd_udp", fluentd_udp) + pulumi.set(__self__, "graphite", graphite) + pulumi.set(__self__, "ism_deletion_after", ism_deletion_after) + pulumi.set(__self__, "ism_jitter", ism_jitter) + pulumi.set(__self__, "ism_job_interval", ism_job_interval) + pulumi.set(__self__, "java_heapspace", java_heapspace) + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + pulumi.set(__self__, "opensearch_tls_ciphers", opensearch_tls_ciphers) + pulumi.set(__self__, "opensearch_tls_protocols", opensearch_tls_protocols) + pulumi.set(__self__, "sgw_acl", sgw_acl) + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> builtins.bool: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter(name="fluentdTcp") + def fluentd_tcp(self) -> builtins.int: + return pulumi.get(self, "fluentd_tcp") + + @property + @pulumi.getter(name="fluentdTls") + def fluentd_tls(self) -> builtins.int: + return pulumi.get(self, "fluentd_tls") + + @property + @pulumi.getter(name="fluentdTlsCiphers") + def fluentd_tls_ciphers(self) -> builtins.str: + return pulumi.get(self, "fluentd_tls_ciphers") + + @property + @pulumi.getter(name="fluentdTlsMaxVersion") + def fluentd_tls_max_version(self) -> builtins.str: + return pulumi.get(self, "fluentd_tls_max_version") + + @property + @pulumi.getter(name="fluentdTlsMinVersion") + def fluentd_tls_min_version(self) -> builtins.str: + return pulumi.get(self, "fluentd_tls_min_version") + + @property + @pulumi.getter(name="fluentdTlsVersion") + def fluentd_tls_version(self) -> builtins.str: + return pulumi.get(self, "fluentd_tls_version") + + @property + @pulumi.getter(name="fluentdUdp") + def fluentd_udp(self) -> builtins.int: + return pulumi.get(self, "fluentd_udp") + + @property + @pulumi.getter + def graphite(self) -> builtins.str: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="ismDeletionAfter") + def ism_deletion_after(self) -> builtins.str: + """ + Combination of an integer and a timerange when an index will be considered "old" and can be deleted. Possible values for the timerange are `s`, `m`, `h` and `d`. + """ + return pulumi.get(self, "ism_deletion_after") + + @property + @pulumi.getter(name="ismJitter") + def ism_jitter(self) -> builtins.float: + return pulumi.get(self, "ism_jitter") + + @property + @pulumi.getter(name="ismJobInterval") + def ism_job_interval(self) -> builtins.int: + """ + Jitter of the execution time. + """ + return pulumi.get(self, "ism_job_interval") + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> builtins.int: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> builtins.int: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> builtins.int: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> builtins.int: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> builtins.str: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> builtins.str: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="opensearchTlsCiphers") + def opensearch_tls_ciphers(self) -> Sequence[builtins.str]: + return pulumi.get(self, "opensearch_tls_ciphers") + + @property + @pulumi.getter(name="opensearchTlsProtocols") + def opensearch_tls_protocols(self) -> Sequence[builtins.str]: + return pulumi.get(self, "opensearch_tls_protocols") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> builtins.str: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Sequence[builtins.str]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + +@pulumi.output_type +class GetMariadbInstanceParametersResult(dict): + def __init__(__self__, *, + enable_monitoring: builtins.bool, + graphite: builtins.str, + max_disk_threshold: builtins.int, + metrics_frequency: builtins.int, + metrics_prefix: builtins.str, + monitoring_instance_id: builtins.str, + sgw_acl: builtins.str, + syslogs: Sequence[builtins.str]): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + """ + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + pulumi.set(__self__, "graphite", graphite) + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + pulumi.set(__self__, "sgw_acl", sgw_acl) + pulumi.set(__self__, "syslogs", syslogs) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> builtins.bool: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> builtins.str: + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> builtins.int: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> builtins.int: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> builtins.str: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> builtins.str: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> builtins.str: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Sequence[builtins.str]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + +@pulumi.output_type +class GetMongodbflexInstanceFlavorResult(dict): + def __init__(__self__, *, + cpu: builtins.int, + description: builtins.str, + id: builtins.str, + ram: builtins.int): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "ram", ram) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def description(self) -> builtins.str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + +@pulumi.output_type +class GetMongodbflexInstanceOptionsResult(dict): + def __init__(__self__, *, + daily_snapshot_retention_days: builtins.int, + monthly_snapshot_retention_months: builtins.int, + point_in_time_window_hours: builtins.int, + snapshot_retention_days: builtins.int, + type: builtins.str, + weekly_snapshot_retention_weeks: builtins.int): + """ + :param builtins.int daily_snapshot_retention_days: The number of days that daily backups will be retained. + :param builtins.int monthly_snapshot_retention_months: The number of months that monthly backups will be retained. + :param builtins.int point_in_time_window_hours: The number of hours back in time the point-in-time recovery feature will be able to recover. + :param builtins.int snapshot_retention_days: The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + :param builtins.str type: Type of the MongoDB Flex instance. + :param builtins.int weekly_snapshot_retention_weeks: The number of weeks that weekly backups will be retained. + """ + pulumi.set(__self__, "daily_snapshot_retention_days", daily_snapshot_retention_days) + pulumi.set(__self__, "monthly_snapshot_retention_months", monthly_snapshot_retention_months) + pulumi.set(__self__, "point_in_time_window_hours", point_in_time_window_hours) + pulumi.set(__self__, "snapshot_retention_days", snapshot_retention_days) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "weekly_snapshot_retention_weeks", weekly_snapshot_retention_weeks) + + @property + @pulumi.getter(name="dailySnapshotRetentionDays") + def daily_snapshot_retention_days(self) -> builtins.int: + """ + The number of days that daily backups will be retained. + """ + return pulumi.get(self, "daily_snapshot_retention_days") + + @property + @pulumi.getter(name="monthlySnapshotRetentionMonths") + def monthly_snapshot_retention_months(self) -> builtins.int: + """ + The number of months that monthly backups will be retained. + """ + return pulumi.get(self, "monthly_snapshot_retention_months") + + @property + @pulumi.getter(name="pointInTimeWindowHours") + def point_in_time_window_hours(self) -> builtins.int: + """ + The number of hours back in time the point-in-time recovery feature will be able to recover. + """ + return pulumi.get(self, "point_in_time_window_hours") + + @property + @pulumi.getter(name="snapshotRetentionDays") + def snapshot_retention_days(self) -> builtins.int: + """ + The number of days that continuous backups (controlled via the `backup_schedule`) will be retained. + """ + return pulumi.get(self, "snapshot_retention_days") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + Type of the MongoDB Flex instance. + """ + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="weeklySnapshotRetentionWeeks") + def weekly_snapshot_retention_weeks(self) -> builtins.int: + """ + The number of weeks that weekly backups will be retained. + """ + return pulumi.get(self, "weekly_snapshot_retention_weeks") + + +@pulumi.output_type +class GetMongodbflexInstanceStorageResult(dict): + def __init__(__self__, *, + class_: builtins.str, + size: builtins.int): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> builtins.str: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> builtins.int: + return pulumi.get(self, "size") + + +@pulumi.output_type +class GetNetworkAreaNetworkRangeResult(dict): + def __init__(__self__, *, + network_range_id: builtins.str, + prefix: builtins.str): + pulumi.set(__self__, "network_range_id", network_range_id) + pulumi.set(__self__, "prefix", prefix) + + @property + @pulumi.getter(name="networkRangeId") + def network_range_id(self) -> builtins.str: + return pulumi.get(self, "network_range_id") + + @property + @pulumi.getter + def prefix(self) -> builtins.str: + return pulumi.get(self, "prefix") + + +@pulumi.output_type +class GetObservabilityAlertgroupRuleResult(dict): + def __init__(__self__, *, + alert: builtins.str, + annotations: Mapping[str, builtins.str], + expression: builtins.str, + for_: builtins.str, + labels: Mapping[str, builtins.str]): + """ + :param builtins.str alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param Mapping[str, builtins.str] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param builtins.str expression: The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param builtins.str for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param Mapping[str, builtins.str] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "annotations", annotations) + pulumi.set(__self__, "expression", expression) + pulumi.set(__self__, "for_", for_) + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> builtins.str: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @property + @pulumi.getter + def annotations(self) -> Mapping[str, builtins.str]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @property + @pulumi.getter + def expression(self) -> builtins.str: + """ + The PromQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @property + @pulumi.getter(name="for") + def for_(self) -> builtins.str: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigResult(dict): + def __init__(__self__, *, + global_: 'outputs.GetObservabilityInstanceAlertConfigGlobalResult', + receivers: Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverResult'], + route: 'outputs.GetObservabilityInstanceAlertConfigRouteResult'): + """ + :param 'GetObservabilityInstanceAlertConfigGlobalArgs' global_: Global configuration for the alerts. + :param Sequence['GetObservabilityInstanceAlertConfigReceiverArgs'] receivers: List of alert receivers. + :param 'GetObservabilityInstanceAlertConfigRouteArgs' route: The route for the alert. + """ + pulumi.set(__self__, "global_", global_) + pulumi.set(__self__, "receivers", receivers) + pulumi.set(__self__, "route", route) + + @property + @pulumi.getter(name="global") + def global_(self) -> 'outputs.GetObservabilityInstanceAlertConfigGlobalResult': + """ + Global configuration for the alerts. + """ + return pulumi.get(self, "global_") + + @property + @pulumi.getter + def receivers(self) -> Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverResult']: + """ + List of alert receivers. + """ + return pulumi.get(self, "receivers") + + @property + @pulumi.getter + def route(self) -> 'outputs.GetObservabilityInstanceAlertConfigRouteResult': + """ + The route for the alert. + """ + return pulumi.get(self, "route") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigGlobalResult(dict): + def __init__(__self__, *, + opsgenie_api_key: builtins.str, + opsgenie_api_url: builtins.str, + resolve_timeout: builtins.str, + smtp_auth_identity: builtins.str, + smtp_auth_password: builtins.str, + smtp_auth_username: builtins.str, + smtp_from: builtins.str, + smtp_smart_host: builtins.str): + """ + :param builtins.str opsgenie_api_key: The API key for OpsGenie. + :param builtins.str opsgenie_api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param builtins.str resolve_timeout: The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + :param builtins.str smtp_auth_identity: SMTP authentication information. Must be a valid email address + :param builtins.str smtp_auth_password: SMTP Auth using LOGIN and PLAIN. + :param builtins.str smtp_auth_username: SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + :param builtins.str smtp_from: The default SMTP From header field. Must be a valid email address + :param builtins.str smtp_smart_host: The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + pulumi.set(__self__, "opsgenie_api_key", opsgenie_api_key) + pulumi.set(__self__, "opsgenie_api_url", opsgenie_api_url) + pulumi.set(__self__, "resolve_timeout", resolve_timeout) + pulumi.set(__self__, "smtp_auth_identity", smtp_auth_identity) + pulumi.set(__self__, "smtp_auth_password", smtp_auth_password) + pulumi.set(__self__, "smtp_auth_username", smtp_auth_username) + pulumi.set(__self__, "smtp_from", smtp_from) + pulumi.set(__self__, "smtp_smart_host", smtp_smart_host) + + @property + @pulumi.getter(name="opsgenieApiKey") + def opsgenie_api_key(self) -> builtins.str: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "opsgenie_api_key") + + @property + @pulumi.getter(name="opsgenieApiUrl") + def opsgenie_api_url(self) -> builtins.str: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "opsgenie_api_url") + + @property + @pulumi.getter(name="resolveTimeout") + def resolve_timeout(self) -> builtins.str: + """ + The default value used by alertmanager if the alert does not include EndsAt. After this time passes, it can declare the alert as resolved if it has not been updated. This has no impact on alerts from Prometheus, as they always include EndsAt. + """ + return pulumi.get(self, "resolve_timeout") + + @property + @pulumi.getter(name="smtpAuthIdentity") + def smtp_auth_identity(self) -> builtins.str: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "smtp_auth_identity") + + @property + @pulumi.getter(name="smtpAuthPassword") + def smtp_auth_password(self) -> builtins.str: + """ + SMTP Auth using LOGIN and PLAIN. + """ + return pulumi.get(self, "smtp_auth_password") + + @property + @pulumi.getter(name="smtpAuthUsername") + def smtp_auth_username(self) -> builtins.str: + """ + SMTP Auth using CRAM-MD5, LOGIN and PLAIN. If empty, Alertmanager doesn't authenticate to the SMTP server. + """ + return pulumi.get(self, "smtp_auth_username") + + @property + @pulumi.getter(name="smtpFrom") + def smtp_from(self) -> builtins.str: + """ + The default SMTP From header field. Must be a valid email address + """ + return pulumi.get(self, "smtp_from") + + @property + @pulumi.getter(name="smtpSmartHost") + def smtp_smart_host(self) -> builtins.str: + """ + The default SMTP smarthost used for sending emails, including port number. Port number usually is 25, or 587 for SMTP over TLS (sometimes referred to as STARTTLS). + """ + return pulumi.get(self, "smtp_smart_host") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigReceiverResult(dict): + def __init__(__self__, *, + email_configs: Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverEmailConfigResult'], + name: builtins.str, + opsgenie_configs: Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult'], + webhooks_configs: Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult']): + """ + :param Sequence['GetObservabilityInstanceAlertConfigReceiverEmailConfigArgs'] email_configs: List of email configurations. + :param builtins.str name: Name of the receiver. + :param Sequence['GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigArgs'] opsgenie_configs: List of OpsGenie configurations. + :param Sequence['GetObservabilityInstanceAlertConfigReceiverWebhooksConfigArgs'] webhooks_configs: List of Webhooks configurations. + """ + pulumi.set(__self__, "email_configs", email_configs) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "opsgenie_configs", opsgenie_configs) + pulumi.set(__self__, "webhooks_configs", webhooks_configs) + + @property + @pulumi.getter(name="emailConfigs") + def email_configs(self) -> Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverEmailConfigResult']: + """ + List of email configurations. + """ + return pulumi.get(self, "email_configs") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Name of the receiver. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="opsgenieConfigs") + def opsgenie_configs(self) -> Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult']: + """ + List of OpsGenie configurations. + """ + return pulumi.get(self, "opsgenie_configs") + + @property + @pulumi.getter(name="webhooksConfigs") + def webhooks_configs(self) -> Sequence['outputs.GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult']: + """ + List of Webhooks configurations. + """ + return pulumi.get(self, "webhooks_configs") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigReceiverEmailConfigResult(dict): + def __init__(__self__, *, + auth_identity: builtins.str, + auth_password: builtins.str, + auth_username: builtins.str, + from_: builtins.str, + smart_host: builtins.str, + to: builtins.str): + """ + :param builtins.str auth_identity: SMTP authentication information. Must be a valid email address + :param builtins.str auth_password: SMTP authentication password. + :param builtins.str auth_username: SMTP authentication username. + :param builtins.str from_: The sender email address. Must be a valid email address + :param builtins.str smart_host: The SMTP host through which emails are sent. + :param builtins.str to: The email address to send notifications to. Must be a valid email address + """ + pulumi.set(__self__, "auth_identity", auth_identity) + pulumi.set(__self__, "auth_password", auth_password) + pulumi.set(__self__, "auth_username", auth_username) + pulumi.set(__self__, "from_", from_) + pulumi.set(__self__, "smart_host", smart_host) + pulumi.set(__self__, "to", to) + + @property + @pulumi.getter(name="authIdentity") + def auth_identity(self) -> builtins.str: + """ + SMTP authentication information. Must be a valid email address + """ + return pulumi.get(self, "auth_identity") + + @property + @pulumi.getter(name="authPassword") + def auth_password(self) -> builtins.str: + """ + SMTP authentication password. + """ + return pulumi.get(self, "auth_password") + + @property + @pulumi.getter(name="authUsername") + def auth_username(self) -> builtins.str: + """ + SMTP authentication username. + """ + return pulumi.get(self, "auth_username") + + @property + @pulumi.getter(name="from") + def from_(self) -> builtins.str: + """ + The sender email address. Must be a valid email address + """ + return pulumi.get(self, "from_") + + @property + @pulumi.getter(name="smartHost") + def smart_host(self) -> builtins.str: + """ + The SMTP host through which emails are sent. + """ + return pulumi.get(self, "smart_host") + + @property + @pulumi.getter + def to(self) -> builtins.str: + """ + The email address to send notifications to. Must be a valid email address + """ + return pulumi.get(self, "to") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigReceiverOpsgenieConfigResult(dict): + def __init__(__self__, *, + api_key: builtins.str, + api_url: builtins.str, + tags: builtins.str): + """ + :param builtins.str api_key: The API key for OpsGenie. + :param builtins.str api_url: The host to send OpsGenie API requests to. Must be a valid URL + :param builtins.str tags: Comma separated list of tags attached to the notifications. + """ + pulumi.set(__self__, "api_key", api_key) + pulumi.set(__self__, "api_url", api_url) + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> builtins.str: + """ + The API key for OpsGenie. + """ + return pulumi.get(self, "api_key") + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> builtins.str: + """ + The host to send OpsGenie API requests to. Must be a valid URL + """ + return pulumi.get(self, "api_url") + + @property + @pulumi.getter + def tags(self) -> builtins.str: + """ + Comma separated list of tags attached to the notifications. + """ + return pulumi.get(self, "tags") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigReceiverWebhooksConfigResult(dict): + def __init__(__self__, *, + ms_teams: builtins.bool, + url: builtins.str): + """ + :param builtins.bool ms_teams: Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + :param builtins.str url: The endpoint to send HTTP POST requests to. Must be a valid URL + """ + pulumi.set(__self__, "ms_teams", ms_teams) + pulumi.set(__self__, "url", url) + + @property + @pulumi.getter(name="msTeams") + def ms_teams(self) -> builtins.bool: + """ + Microsoft Teams webhooks require special handling, set this to true if the webhook is for Microsoft Teams. + """ + return pulumi.get(self, "ms_teams") + + @property + @pulumi.getter + def url(self) -> builtins.str: + """ + The endpoint to send HTTP POST requests to. Must be a valid URL + """ + return pulumi.get(self, "url") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigRouteResult(dict): + def __init__(__self__, *, + group_bies: Sequence[builtins.str], + group_interval: builtins.str, + group_wait: builtins.str, + match: Mapping[str, builtins.str], + match_regex: Mapping[str, builtins.str], + receiver: builtins.str, + repeat_interval: builtins.str, + routes: Sequence['outputs.GetObservabilityInstanceAlertConfigRouteRouteResult']): + """ + :param Sequence[builtins.str] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param builtins.str group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param builtins.str group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + :param Mapping[str, builtins.str] match: A set of equality matchers an alert has to fulfill to match the node. + :param Mapping[str, builtins.str] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param builtins.str receiver: The name of the receiver to route the alerts to. + :param builtins.str repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + :param Sequence['GetObservabilityInstanceAlertConfigRouteRouteArgs'] routes: List of child routes. + """ + pulumi.set(__self__, "group_bies", group_bies) + pulumi.set(__self__, "group_interval", group_interval) + pulumi.set(__self__, "group_wait", group_wait) + pulumi.set(__self__, "match", match) + pulumi.set(__self__, "match_regex", match_regex) + pulumi.set(__self__, "receiver", receiver) + pulumi.set(__self__, "repeat_interval", repeat_interval) + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Sequence[builtins.str]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> builtins.str: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> builtins.str: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) . + """ + return pulumi.get(self, "group_wait") + + @property + @pulumi.getter + def match(self) -> Mapping[str, builtins.str]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Mapping[str, builtins.str]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @property + @pulumi.getter + def receiver(self) -> builtins.str: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> builtins.str: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + @property + @pulumi.getter + def routes(self) -> Sequence['outputs.GetObservabilityInstanceAlertConfigRouteRouteResult']: + """ + List of child routes. + """ + return pulumi.get(self, "routes") + + +@pulumi.output_type +class GetObservabilityInstanceAlertConfigRouteRouteResult(dict): + def __init__(__self__, *, + group_bies: Sequence[builtins.str], + group_interval: builtins.str, + group_wait: builtins.str, + match: Mapping[str, builtins.str], + match_regex: Mapping[str, builtins.str], + receiver: builtins.str, + repeat_interval: builtins.str): + """ + :param Sequence[builtins.str] group_bies: The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + :param builtins.str group_interval: How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + :param builtins.str group_wait: How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + :param Mapping[str, builtins.str] match: A set of equality matchers an alert has to fulfill to match the node. + :param Mapping[str, builtins.str] match_regex: A set of regex-matchers an alert has to fulfill to match the node. + :param builtins.str receiver: The name of the receiver to route the alerts to. + :param builtins.str repeat_interval: How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + pulumi.set(__self__, "group_bies", group_bies) + pulumi.set(__self__, "group_interval", group_interval) + pulumi.set(__self__, "group_wait", group_wait) + pulumi.set(__self__, "match", match) + pulumi.set(__self__, "match_regex", match_regex) + pulumi.set(__self__, "receiver", receiver) + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Sequence[builtins.str]: + """ + The labels by which incoming alerts are grouped together. For example, multiple alerts coming in for cluster=A and alertname=LatencyHigh would be batched into a single group. To aggregate by all possible labels use the special value '...' as the sole label name, for example: group_by: ['...']. This effectively disables aggregation entirely, passing through all alerts as-is. This is unlikely to be what you want, unless you have a very low alert volume or your upstream notification system performs its own grouping. + """ + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter(name="groupInterval") + def group_interval(self) -> builtins.str: + """ + How long to wait before sending a notification about new alerts that are added to a group of alerts for which an initial notification has already been sent. (Usually ~5m or more.) + """ + return pulumi.get(self, "group_interval") + + @property + @pulumi.getter(name="groupWait") + def group_wait(self) -> builtins.str: + """ + How long to initially wait to send a notification for a group of alerts. Allows to wait for an inhibiting alert to arrive or collect more initial alerts for the same group. (Usually ~0s to few minutes.) + """ + return pulumi.get(self, "group_wait") + + @property + @pulumi.getter + def match(self) -> Mapping[str, builtins.str]: + """ + A set of equality matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match") + + @property + @pulumi.getter(name="matchRegex") + def match_regex(self) -> Mapping[str, builtins.str]: + """ + A set of regex-matchers an alert has to fulfill to match the node. + """ + return pulumi.get(self, "match_regex") + + @property + @pulumi.getter + def receiver(self) -> builtins.str: + """ + The name of the receiver to route the alerts to. + """ + return pulumi.get(self, "receiver") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> builtins.str: + """ + How long to wait before sending a notification again if it has already been sent successfully for an alert. (Usually ~3h or more). + """ + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class GetObservabilityLogalertgroupRuleResult(dict): + def __init__(__self__, *, + alert: builtins.str, + annotations: Mapping[str, builtins.str], + expression: builtins.str, + for_: builtins.str, + labels: Mapping[str, builtins.str]): + """ + :param builtins.str alert: The name of the alert rule. Is the identifier and must be unique in the group. + :param Mapping[str, builtins.str] annotations: A map of key:value. Annotations to add or overwrite for each alert + :param builtins.str expression: The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + :param builtins.str for_: Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + :param Mapping[str, builtins.str] labels: A map of key:value. Labels to add or overwrite for each alert + """ + pulumi.set(__self__, "alert", alert) + pulumi.set(__self__, "annotations", annotations) + pulumi.set(__self__, "expression", expression) + pulumi.set(__self__, "for_", for_) + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def alert(self) -> builtins.str: + """ + The name of the alert rule. Is the identifier and must be unique in the group. + """ + return pulumi.get(self, "alert") + + @property + @pulumi.getter + def annotations(self) -> Mapping[str, builtins.str]: + """ + A map of key:value. Annotations to add or overwrite for each alert + """ + return pulumi.get(self, "annotations") + + @property + @pulumi.getter + def expression(self) -> builtins.str: + """ + The LogQL expression to evaluate. Every evaluation cycle this is evaluated at the current time, and all resultant time series become pending/firing alerts. + """ + return pulumi.get(self, "expression") + + @property + @pulumi.getter(name="for") + def for_(self) -> builtins.str: + """ + Alerts are considered firing once they have been returned for this long. Alerts which have not yet fired for long enough are considered pending. Default is 0s + """ + return pulumi.get(self, "for_") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + A map of key:value. Labels to add or overwrite for each alert + """ + return pulumi.get(self, "labels") + + +@pulumi.output_type +class GetObservabilityScrapeconfigBasicAuthResult(dict): + def __init__(__self__, *, + password: builtins.str, + username: builtins.str): + """ + :param builtins.str password: Specifies basic auth password. + :param builtins.str username: Specifies basic auth username. + """ + pulumi.set(__self__, "password", password) + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def password(self) -> builtins.str: + """ + Specifies basic auth password. + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter + def username(self) -> builtins.str: + """ + Specifies basic auth username. + """ + return pulumi.get(self, "username") + + +@pulumi.output_type +class GetObservabilityScrapeconfigSaml2Result(dict): + def __init__(__self__, *, + enable_url_parameters: builtins.bool): + """ + :param builtins.bool enable_url_parameters: Specifies if URL parameters are enabled + """ + pulumi.set(__self__, "enable_url_parameters", enable_url_parameters) + + @property + @pulumi.getter(name="enableUrlParameters") + def enable_url_parameters(self) -> builtins.bool: + """ + Specifies if URL parameters are enabled + """ + return pulumi.get(self, "enable_url_parameters") + + +@pulumi.output_type +class GetObservabilityScrapeconfigTargetResult(dict): + def __init__(__self__, *, + labels: Mapping[str, builtins.str], + urls: Sequence[builtins.str]): + """ + :param Mapping[str, builtins.str] labels: Specifies labels. + :param Sequence[builtins.str] urls: Specifies target URLs. + """ + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "urls", urls) + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Specifies labels. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def urls(self) -> Sequence[builtins.str]: + """ + Specifies target URLs. + """ + return pulumi.get(self, "urls") + + +@pulumi.output_type +class GetOpensearchInstanceParametersResult(dict): + def __init__(__self__, *, + enable_monitoring: builtins.bool, + graphite: builtins.str, + java_garbage_collector: builtins.str, + java_heapspace: builtins.int, + java_maxmetaspace: builtins.int, + max_disk_threshold: builtins.int, + metrics_frequency: builtins.int, + metrics_prefix: builtins.str, + monitoring_instance_id: builtins.str, + plugins: Sequence[builtins.str], + sgw_acl: builtins.str, + syslogs: Sequence[builtins.str], + tls_ciphers: Sequence[builtins.str], + tls_protocols: builtins.str): + """ + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + :param builtins.str java_garbage_collector: The garbage collector to use for OpenSearch. + :param builtins.int java_heapspace: The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + :param builtins.int java_maxmetaspace: The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted (in seconds). + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param Sequence[builtins.str] plugins: List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_protocols: The TLS protocol to use. + """ + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + pulumi.set(__self__, "graphite", graphite) + pulumi.set(__self__, "java_garbage_collector", java_garbage_collector) + pulumi.set(__self__, "java_heapspace", java_heapspace) + pulumi.set(__self__, "java_maxmetaspace", java_maxmetaspace) + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + pulumi.set(__self__, "plugins", plugins) + pulumi.set(__self__, "sgw_acl", sgw_acl) + pulumi.set(__self__, "syslogs", syslogs) + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> builtins.bool: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> builtins.str: + """ + If set, monitoring with Graphite will be enabled. Expects the host and port where the Graphite metrics should be sent to (host:port). + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="javaGarbageCollector") + def java_garbage_collector(self) -> builtins.str: + """ + The garbage collector to use for OpenSearch. + """ + return pulumi.get(self, "java_garbage_collector") + + @property + @pulumi.getter(name="javaHeapspace") + def java_heapspace(self) -> builtins.int: + """ + The amount of memory (in MB) allocated as heap by the JVM for OpenSearch. + """ + return pulumi.get(self, "java_heapspace") + + @property + @pulumi.getter(name="javaMaxmetaspace") + def java_maxmetaspace(self) -> builtins.int: + """ + The amount of memory (in MB) used by the JVM to store metadata for OpenSearch. + """ + return pulumi.get(self, "java_maxmetaspace") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> builtins.int: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> builtins.int: + """ + The frequency in seconds at which metrics are emitted (in seconds). + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> builtins.str: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key. + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> builtins.str: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter + def plugins(self) -> Sequence[builtins.str]: + """ + List of plugins to install. Must be a supported plugin name. The plugins `repository-s3` and `repository-azure` are enabled by default and cannot be disabled. + """ + return pulumi.get(self, "plugins") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> builtins.str: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Sequence[builtins.str]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Sequence[builtins.str]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> builtins.str: + """ + The TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class GetPostgresflexInstanceFlavorResult(dict): + def __init__(__self__, *, + cpu: builtins.int, + description: builtins.str, + id: builtins.str, + ram: builtins.int): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "ram", ram) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def description(self) -> builtins.str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + +@pulumi.output_type +class GetPostgresflexInstanceStorageResult(dict): + def __init__(__self__, *, + class_: builtins.str, + size: builtins.int): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> builtins.str: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> builtins.int: + return pulumi.get(self, "size") + + +@pulumi.output_type +class GetPublicIpRangesPublicIpRangeResult(dict): + def __init__(__self__, *, + cidr: builtins.str): + """ + :param builtins.str cidr: Classless Inter-Domain Routing (CIDR) + """ + pulumi.set(__self__, "cidr", cidr) + + @property + @pulumi.getter + def cidr(self) -> builtins.str: + """ + Classless Inter-Domain Routing (CIDR) + """ + return pulumi.get(self, "cidr") + + +@pulumi.output_type +class GetRabbitmqInstanceParametersResult(dict): + def __init__(__self__, *, + consumer_timeout: builtins.int, + enable_monitoring: builtins.bool, + graphite: builtins.str, + max_disk_threshold: builtins.int, + metrics_frequency: builtins.int, + metrics_prefix: builtins.str, + monitoring_instance_id: builtins.str, + plugins: Sequence[builtins.str], + roles: Sequence[builtins.str], + sgw_acl: builtins.str, + syslogs: Sequence[builtins.str], + tls_ciphers: Sequence[builtins.str], + tls_protocols: builtins.str): + """ + :param builtins.int consumer_timeout: The timeout in milliseconds for the consumer. + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.str graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param Sequence[builtins.str] plugins: List of plugins to install. Must be a supported plugin name. + :param Sequence[builtins.str] roles: List of roles to assign to the instance. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_protocols: TLS protocol to use. + """ + pulumi.set(__self__, "consumer_timeout", consumer_timeout) + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + pulumi.set(__self__, "graphite", graphite) + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + pulumi.set(__self__, "plugins", plugins) + pulumi.set(__self__, "roles", roles) + pulumi.set(__self__, "sgw_acl", sgw_acl) + pulumi.set(__self__, "syslogs", syslogs) + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="consumerTimeout") + def consumer_timeout(self) -> builtins.int: + """ + The timeout in milliseconds for the consumer. + """ + return pulumi.get(self, "consumer_timeout") + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> builtins.bool: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter + def graphite(self) -> builtins.str: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> builtins.int: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> builtins.int: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> builtins.str: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> builtins.str: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter + def plugins(self) -> Sequence[builtins.str]: + """ + List of plugins to install. Must be a supported plugin name. + """ + return pulumi.get(self, "plugins") + + @property + @pulumi.getter + def roles(self) -> Sequence[builtins.str]: + """ + List of roles to assign to the instance. + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> builtins.str: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def syslogs(self) -> Sequence[builtins.str]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Sequence[builtins.str]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> builtins.str: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class GetRedisInstanceParametersResult(dict): + def __init__(__self__, *, + down_after_milliseconds: builtins.int, + enable_monitoring: builtins.bool, + failover_timeout: builtins.int, + graphite: builtins.str, + lazyfree_lazy_eviction: builtins.str, + lazyfree_lazy_expire: builtins.str, + lua_time_limit: builtins.int, + max_disk_threshold: builtins.int, + maxclients: builtins.int, + maxmemory_policy: builtins.str, + maxmemory_samples: builtins.int, + metrics_frequency: builtins.int, + metrics_prefix: builtins.str, + min_replicas_max_lag: builtins.int, + monitoring_instance_id: builtins.str, + notify_keyspace_events: builtins.str, + sgw_acl: builtins.str, + snapshot: builtins.str, + syslogs: Sequence[builtins.str], + tls_ciphers: Sequence[builtins.str], + tls_ciphersuites: builtins.str, + tls_protocols: builtins.str): + """ + :param builtins.int down_after_milliseconds: The number of milliseconds after which the instance is considered down. + :param builtins.bool enable_monitoring: Enable monitoring. + :param builtins.int failover_timeout: The failover timeout in milliseconds. + :param builtins.str graphite: Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + :param builtins.str lazyfree_lazy_eviction: The lazy eviction enablement (yes or no). + :param builtins.str lazyfree_lazy_expire: The lazy expire enablement (yes or no). + :param builtins.int lua_time_limit: The Lua time limit. + :param builtins.int max_disk_threshold: The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + :param builtins.int maxclients: The maximum number of clients. + :param builtins.str maxmemory_policy: The policy to handle the maximum memory (volatile-lru, noeviction, etc). + :param builtins.int maxmemory_samples: The maximum memory samples. + :param builtins.int metrics_frequency: The frequency in seconds at which metrics are emitted. + :param builtins.str metrics_prefix: The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + :param builtins.int min_replicas_max_lag: The minimum replicas maximum lag. + :param builtins.str monitoring_instance_id: The ID of the STACKIT monitoring instance. + :param builtins.str notify_keyspace_events: The notify keyspace events. + :param builtins.str sgw_acl: Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + :param builtins.str snapshot: The snapshot configuration. + :param Sequence[builtins.str] syslogs: List of syslog servers to send logs to. + :param Sequence[builtins.str] tls_ciphers: List of TLS ciphers to use. + :param builtins.str tls_ciphersuites: TLS cipher suites to use. + :param builtins.str tls_protocols: TLS protocol to use. + """ + pulumi.set(__self__, "down_after_milliseconds", down_after_milliseconds) + pulumi.set(__self__, "enable_monitoring", enable_monitoring) + pulumi.set(__self__, "failover_timeout", failover_timeout) + pulumi.set(__self__, "graphite", graphite) + pulumi.set(__self__, "lazyfree_lazy_eviction", lazyfree_lazy_eviction) + pulumi.set(__self__, "lazyfree_lazy_expire", lazyfree_lazy_expire) + pulumi.set(__self__, "lua_time_limit", lua_time_limit) + pulumi.set(__self__, "max_disk_threshold", max_disk_threshold) + pulumi.set(__self__, "maxclients", maxclients) + pulumi.set(__self__, "maxmemory_policy", maxmemory_policy) + pulumi.set(__self__, "maxmemory_samples", maxmemory_samples) + pulumi.set(__self__, "metrics_frequency", metrics_frequency) + pulumi.set(__self__, "metrics_prefix", metrics_prefix) + pulumi.set(__self__, "min_replicas_max_lag", min_replicas_max_lag) + pulumi.set(__self__, "monitoring_instance_id", monitoring_instance_id) + pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events) + pulumi.set(__self__, "sgw_acl", sgw_acl) + pulumi.set(__self__, "snapshot", snapshot) + pulumi.set(__self__, "syslogs", syslogs) + pulumi.set(__self__, "tls_ciphers", tls_ciphers) + pulumi.set(__self__, "tls_ciphersuites", tls_ciphersuites) + pulumi.set(__self__, "tls_protocols", tls_protocols) + + @property + @pulumi.getter(name="downAfterMilliseconds") + def down_after_milliseconds(self) -> builtins.int: + """ + The number of milliseconds after which the instance is considered down. + """ + return pulumi.get(self, "down_after_milliseconds") + + @property + @pulumi.getter(name="enableMonitoring") + def enable_monitoring(self) -> builtins.bool: + """ + Enable monitoring. + """ + return pulumi.get(self, "enable_monitoring") + + @property + @pulumi.getter(name="failoverTimeout") + def failover_timeout(self) -> builtins.int: + """ + The failover timeout in milliseconds. + """ + return pulumi.get(self, "failover_timeout") + + @property + @pulumi.getter + def graphite(self) -> builtins.str: + """ + Graphite server URL (host and port). If set, monitoring with Graphite will be enabled. + """ + return pulumi.get(self, "graphite") + + @property + @pulumi.getter(name="lazyfreeLazyEviction") + def lazyfree_lazy_eviction(self) -> builtins.str: + """ + The lazy eviction enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_eviction") + + @property + @pulumi.getter(name="lazyfreeLazyExpire") + def lazyfree_lazy_expire(self) -> builtins.str: + """ + The lazy expire enablement (yes or no). + """ + return pulumi.get(self, "lazyfree_lazy_expire") + + @property + @pulumi.getter(name="luaTimeLimit") + def lua_time_limit(self) -> builtins.int: + """ + The Lua time limit. + """ + return pulumi.get(self, "lua_time_limit") + + @property + @pulumi.getter(name="maxDiskThreshold") + def max_disk_threshold(self) -> builtins.int: + """ + The maximum disk threshold in MB. If the disk usage exceeds this threshold, the instance will be stopped. + """ + return pulumi.get(self, "max_disk_threshold") + + @property + @pulumi.getter + def maxclients(self) -> builtins.int: + """ + The maximum number of clients. + """ + return pulumi.get(self, "maxclients") + + @property + @pulumi.getter(name="maxmemoryPolicy") + def maxmemory_policy(self) -> builtins.str: + """ + The policy to handle the maximum memory (volatile-lru, noeviction, etc). + """ + return pulumi.get(self, "maxmemory_policy") + + @property + @pulumi.getter(name="maxmemorySamples") + def maxmemory_samples(self) -> builtins.int: + """ + The maximum memory samples. + """ + return pulumi.get(self, "maxmemory_samples") + + @property + @pulumi.getter(name="metricsFrequency") + def metrics_frequency(self) -> builtins.int: + """ + The frequency in seconds at which metrics are emitted. + """ + return pulumi.get(self, "metrics_frequency") + + @property + @pulumi.getter(name="metricsPrefix") + def metrics_prefix(self) -> builtins.str: + """ + The prefix for the metrics. Could be useful when using Graphite monitoring to prefix the metrics with a certain value, like an API key + """ + return pulumi.get(self, "metrics_prefix") + + @property + @pulumi.getter(name="minReplicasMaxLag") + def min_replicas_max_lag(self) -> builtins.int: + """ + The minimum replicas maximum lag. + """ + return pulumi.get(self, "min_replicas_max_lag") + + @property + @pulumi.getter(name="monitoringInstanceId") + def monitoring_instance_id(self) -> builtins.str: + """ + The ID of the STACKIT monitoring instance. + """ + return pulumi.get(self, "monitoring_instance_id") + + @property + @pulumi.getter(name="notifyKeyspaceEvents") + def notify_keyspace_events(self) -> builtins.str: + """ + The notify keyspace events. + """ + return pulumi.get(self, "notify_keyspace_events") + + @property + @pulumi.getter(name="sgwAcl") + def sgw_acl(self) -> builtins.str: + """ + Comma separated list of IP networks in CIDR notation which are allowed to access this instance. + """ + return pulumi.get(self, "sgw_acl") + + @property + @pulumi.getter + def snapshot(self) -> builtins.str: + """ + The snapshot configuration. + """ + return pulumi.get(self, "snapshot") + + @property + @pulumi.getter + def syslogs(self) -> Sequence[builtins.str]: + """ + List of syslog servers to send logs to. + """ + return pulumi.get(self, "syslogs") + + @property + @pulumi.getter(name="tlsCiphers") + def tls_ciphers(self) -> Sequence[builtins.str]: + """ + List of TLS ciphers to use. + """ + return pulumi.get(self, "tls_ciphers") + + @property + @pulumi.getter(name="tlsCiphersuites") + def tls_ciphersuites(self) -> builtins.str: + """ + TLS cipher suites to use. + """ + return pulumi.get(self, "tls_ciphersuites") + + @property + @pulumi.getter(name="tlsProtocols") + def tls_protocols(self) -> builtins.str: + """ + TLS protocol to use. + """ + return pulumi.get(self, "tls_protocols") + + +@pulumi.output_type +class GetSecurityGroupRuleIcmpParametersResult(dict): + def __init__(__self__, *, + code: builtins.int, + type: builtins.int): + """ + :param builtins.int code: ICMP code. Can be set if the protocol is ICMP. + :param builtins.int type: ICMP type. Can be set if the protocol is ICMP. + """ + pulumi.set(__self__, "code", code) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def code(self) -> builtins.int: + """ + ICMP code. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "code") + + @property + @pulumi.getter + def type(self) -> builtins.int: + """ + ICMP type. Can be set if the protocol is ICMP. + """ + return pulumi.get(self, "type") + + +@pulumi.output_type +class GetSecurityGroupRulePortRangeResult(dict): + def __init__(__self__, *, + max: builtins.int, + min: builtins.int): + """ + :param builtins.int max: The maximum port number. Should be greater or equal to the minimum. + :param builtins.int min: The minimum port number. Should be less or equal to the minimum. + """ + pulumi.set(__self__, "max", max) + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> builtins.int: + """ + The maximum port number. Should be greater or equal to the minimum. + """ + return pulumi.get(self, "max") + + @property + @pulumi.getter + def min(self) -> builtins.int: + """ + The minimum port number. Should be less or equal to the minimum. + """ + return pulumi.get(self, "min") + + +@pulumi.output_type +class GetSecurityGroupRuleProtocolResult(dict): + def __init__(__self__, *, + name: builtins.str, + number: builtins.int): + """ + :param builtins.str name: The protocol name which the rule should match. + :param builtins.int number: The protocol number which the rule should match. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "number", number) + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The protocol name which the rule should match. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def number(self) -> builtins.int: + """ + The protocol number which the rule should match. + """ + return pulumi.get(self, "number") + + +@pulumi.output_type +class GetServerBackupScheduleBackupPropertiesResult(dict): + def __init__(__self__, *, + name: builtins.str, + retention_period: builtins.int, + volume_ids: Sequence[builtins.str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "retention_period", retention_period) + pulumi.set(__self__, "volume_ids", volume_ids) + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="retentionPeriod") + def retention_period(self) -> builtins.int: + return pulumi.get(self, "retention_period") + + @property + @pulumi.getter(name="volumeIds") + def volume_ids(self) -> Sequence[builtins.str]: + return pulumi.get(self, "volume_ids") + + +@pulumi.output_type +class GetServerBackupSchedulesItemResult(dict): + def __init__(__self__, *, + backup_properties: 'outputs.GetServerBackupSchedulesItemBackupPropertiesResult', + backup_schedule_id: builtins.int, + enabled: builtins.bool, + name: builtins.str, + rrule: builtins.str): + """ + :param 'GetServerBackupSchedulesItemBackupPropertiesArgs' backup_properties: Backup schedule details for the backups. + :param builtins.bool enabled: Is the backup schedule enabled or disabled. + :param builtins.str name: The backup schedule name. + :param builtins.str rrule: Backup schedule described in `rrule` (recurrence rule) format. + """ + pulumi.set(__self__, "backup_properties", backup_properties) + pulumi.set(__self__, "backup_schedule_id", backup_schedule_id) + pulumi.set(__self__, "enabled", enabled) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "rrule", rrule) + + @property + @pulumi.getter(name="backupProperties") + def backup_properties(self) -> 'outputs.GetServerBackupSchedulesItemBackupPropertiesResult': + """ + Backup schedule details for the backups. + """ + return pulumi.get(self, "backup_properties") + + @property + @pulumi.getter(name="backupScheduleId") + def backup_schedule_id(self) -> builtins.int: + return pulumi.get(self, "backup_schedule_id") + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is the backup schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The backup schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def rrule(self) -> builtins.str: + """ + Backup schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + +@pulumi.output_type +class GetServerBackupSchedulesItemBackupPropertiesResult(dict): + def __init__(__self__, *, + name: builtins.str, + retention_period: builtins.int, + volume_ids: Sequence[builtins.str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "retention_period", retention_period) + pulumi.set(__self__, "volume_ids", volume_ids) + + @property + @pulumi.getter + def name(self) -> builtins.str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="retentionPeriod") + def retention_period(self) -> builtins.int: + return pulumi.get(self, "retention_period") + + @property + @pulumi.getter(name="volumeIds") + def volume_ids(self) -> Sequence[builtins.str]: + return pulumi.get(self, "volume_ids") + + +@pulumi.output_type +class GetServerBootVolumeResult(dict): + def __init__(__self__, *, + delete_on_termination: builtins.bool, + id: builtins.str): + """ + :param builtins.bool delete_on_termination: Delete the volume during the termination of the server. + :param builtins.str id: The ID of the boot volume + """ + pulumi.set(__self__, "delete_on_termination", delete_on_termination) + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter(name="deleteOnTermination") + def delete_on_termination(self) -> builtins.bool: + """ + Delete the volume during the termination of the server. + """ + return pulumi.get(self, "delete_on_termination") + + @property + @pulumi.getter + def id(self) -> builtins.str: + """ + The ID of the boot volume + """ + return pulumi.get(self, "id") + + +@pulumi.output_type +class GetServerUpdateSchedulesItemResult(dict): + def __init__(__self__, *, + enabled: builtins.bool, + maintenance_window: builtins.int, + name: builtins.str, + rrule: builtins.str, + update_schedule_id: builtins.int): + """ + :param builtins.bool enabled: Is the update schedule enabled or disabled. + :param builtins.int maintenance_window: Maintenance window [1..24]. + :param builtins.str name: The update schedule name. + :param builtins.str rrule: Update schedule described in `rrule` (recurrence rule) format. + """ + pulumi.set(__self__, "enabled", enabled) + pulumi.set(__self__, "maintenance_window", maintenance_window) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "rrule", rrule) + pulumi.set(__self__, "update_schedule_id", update_schedule_id) + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is the update schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter(name="maintenanceWindow") + def maintenance_window(self) -> builtins.int: + """ + Maintenance window [1..24]. + """ + return pulumi.get(self, "maintenance_window") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + The update schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def rrule(self) -> builtins.str: + """ + Update schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @property + @pulumi.getter(name="updateScheduleId") + def update_schedule_id(self) -> builtins.int: + return pulumi.get(self, "update_schedule_id") + + +@pulumi.output_type +class GetSkeClusterExtensionsResult(dict): + def __init__(__self__, *, + acl: 'outputs.GetSkeClusterExtensionsAclResult', + argus: 'outputs.GetSkeClusterExtensionsArgusResult', + dns: 'outputs.GetSkeClusterExtensionsDnsResult'): + """ + :param 'GetSkeClusterExtensionsAclArgs' acl: Cluster access control configuration + :param 'GetSkeClusterExtensionsArgusArgs' argus: A single argus block as defined below + :param 'GetSkeClusterExtensionsDnsArgs' dns: DNS extension configuration + """ + pulumi.set(__self__, "acl", acl) + pulumi.set(__self__, "argus", argus) + pulumi.set(__self__, "dns", dns) + + @property + @pulumi.getter + def acl(self) -> 'outputs.GetSkeClusterExtensionsAclResult': + """ + Cluster access control configuration + """ + return pulumi.get(self, "acl") + + @property + @pulumi.getter + def argus(self) -> 'outputs.GetSkeClusterExtensionsArgusResult': + """ + A single argus block as defined below + """ + return pulumi.get(self, "argus") + + @property + @pulumi.getter + def dns(self) -> 'outputs.GetSkeClusterExtensionsDnsResult': + """ + DNS extension configuration + """ + return pulumi.get(self, "dns") + + +@pulumi.output_type +class GetSkeClusterExtensionsAclResult(dict): + def __init__(__self__, *, + allowed_cidrs: Sequence[builtins.str], + enabled: builtins.bool): + """ + :param Sequence[builtins.str] allowed_cidrs: Specify a list of CIDRs to whitelist + :param builtins.bool enabled: Is ACL enabled? + """ + pulumi.set(__self__, "allowed_cidrs", allowed_cidrs) + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="allowedCidrs") + def allowed_cidrs(self) -> Sequence[builtins.str]: + """ + Specify a list of CIDRs to whitelist + """ + return pulumi.get(self, "allowed_cidrs") + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Is ACL enabled? + """ + return pulumi.get(self, "enabled") + + +@pulumi.output_type +class GetSkeClusterExtensionsArgusResult(dict): + def __init__(__self__, *, + argus_instance_id: builtins.str, + enabled: builtins.bool): + """ + :param builtins.str argus_instance_id: Instance ID of argus + :param builtins.bool enabled: Flag to enable/disable argus extensions. + """ + pulumi.set(__self__, "argus_instance_id", argus_instance_id) + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="argusInstanceId") + def argus_instance_id(self) -> builtins.str: + """ + Instance ID of argus + """ + return pulumi.get(self, "argus_instance_id") + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Flag to enable/disable argus extensions. + """ + return pulumi.get(self, "enabled") + + +@pulumi.output_type +class GetSkeClusterExtensionsDnsResult(dict): + def __init__(__self__, *, + enabled: builtins.bool, + zones: Sequence[builtins.str]): + """ + :param builtins.bool enabled: Flag to enable/disable DNS extensions + :param Sequence[builtins.str] zones: Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + pulumi.set(__self__, "enabled", enabled) + pulumi.set(__self__, "zones", zones) + + @property + @pulumi.getter + def enabled(self) -> builtins.bool: + """ + Flag to enable/disable DNS extensions + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def zones(self) -> Sequence[builtins.str]: + """ + Specify a list of domain filters for externalDNS (e.g., `foo.runs.onstackit.cloud`) + """ + return pulumi.get(self, "zones") + + +@pulumi.output_type +class GetSkeClusterHibernationResult(dict): + def __init__(__self__, *, + end: builtins.str, + start: builtins.str, + timezone: builtins.str): + """ + :param builtins.str end: End time of hibernation, in crontab syntax. + :param builtins.str start: Start time of cluster hibernation in crontab syntax. + :param builtins.str timezone: Timezone name corresponding to a file in the IANA Time Zone database. + """ + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + pulumi.set(__self__, "timezone", timezone) + + @property + @pulumi.getter + def end(self) -> builtins.str: + """ + End time of hibernation, in crontab syntax. + """ + return pulumi.get(self, "end") + + @property + @pulumi.getter + def start(self) -> builtins.str: + """ + Start time of cluster hibernation in crontab syntax. + """ + return pulumi.get(self, "start") + + @property + @pulumi.getter + def timezone(self) -> builtins.str: + """ + Timezone name corresponding to a file in the IANA Time Zone database. + """ + return pulumi.get(self, "timezone") + + +@pulumi.output_type +class GetSkeClusterMaintenanceResult(dict): + def __init__(__self__, *, + enable_kubernetes_version_updates: builtins.bool, + enable_machine_image_version_updates: builtins.bool, + end: builtins.str, + start: builtins.str): + """ + :param builtins.bool enable_kubernetes_version_updates: Flag to enable/disable auto-updates of the Kubernetes version. + :param builtins.bool enable_machine_image_version_updates: Flag to enable/disable auto-updates of the OS image version. + :param builtins.str end: Date time for maintenance window end. + :param builtins.str start: Date time for maintenance window start. + """ + pulumi.set(__self__, "enable_kubernetes_version_updates", enable_kubernetes_version_updates) + pulumi.set(__self__, "enable_machine_image_version_updates", enable_machine_image_version_updates) + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + + @property + @pulumi.getter(name="enableKubernetesVersionUpdates") + def enable_kubernetes_version_updates(self) -> builtins.bool: + """ + Flag to enable/disable auto-updates of the Kubernetes version. + """ + return pulumi.get(self, "enable_kubernetes_version_updates") + + @property + @pulumi.getter(name="enableMachineImageVersionUpdates") + def enable_machine_image_version_updates(self) -> builtins.bool: + """ + Flag to enable/disable auto-updates of the OS image version. + """ + return pulumi.get(self, "enable_machine_image_version_updates") + + @property + @pulumi.getter + def end(self) -> builtins.str: + """ + Date time for maintenance window end. + """ + return pulumi.get(self, "end") + + @property + @pulumi.getter + def start(self) -> builtins.str: + """ + Date time for maintenance window start. + """ + return pulumi.get(self, "start") + + +@pulumi.output_type +class GetSkeClusterNetworkResult(dict): + def __init__(__self__, *, + id: builtins.str): + """ + :param builtins.str id: ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + pulumi.set(__self__, "id", id) + + @property + @pulumi.getter + def id(self) -> builtins.str: + """ + ID of the STACKIT Network Area (SNA) network into which the cluster will be deployed. + """ + return pulumi.get(self, "id") + + +@pulumi.output_type +class GetSkeClusterNodePoolResult(dict): + def __init__(__self__, *, + allow_system_components: builtins.bool, + availability_zones: Sequence[builtins.str], + cri: builtins.str, + labels: Mapping[str, builtins.str], + machine_type: builtins.str, + max_surge: builtins.int, + max_unavailable: builtins.int, + maximum: builtins.int, + minimum: builtins.int, + name: builtins.str, + os_name: builtins.str, + os_version: builtins.str, + os_version_min: builtins.str, + os_version_used: builtins.str, + taints: Sequence['outputs.GetSkeClusterNodePoolTaintResult'], + volume_size: builtins.int, + volume_type: builtins.str): + """ + :param builtins.bool allow_system_components: Allow system components to run on this node pool. + :param Sequence[builtins.str] availability_zones: Specify a list of availability zones. + :param builtins.str cri: Specifies the container runtime. + :param Mapping[str, builtins.str] labels: Labels to add to each node. + :param builtins.str machine_type: The machine type. + :param builtins.int max_surge: The maximum number of nodes upgraded simultaneously. + :param builtins.int max_unavailable: The maximum number of nodes unavailable during upgraded. + :param builtins.int maximum: Maximum number of nodes in the pool. + :param builtins.int minimum: Minimum number of nodes in the pool. + :param builtins.str name: Specifies the name of the node pool. + :param builtins.str os_name: The name of the OS image. + :param builtins.str os_version: The OS image version. + :param builtins.str os_version_min: The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + :param builtins.str os_version_used: Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param Sequence['GetSkeClusterNodePoolTaintArgs'] taints: Specifies a taint list as defined below. + :param builtins.int volume_size: The volume size in GB. + :param builtins.str volume_type: Specifies the volume type. + """ + pulumi.set(__self__, "allow_system_components", allow_system_components) + pulumi.set(__self__, "availability_zones", availability_zones) + pulumi.set(__self__, "cri", cri) + pulumi.set(__self__, "labels", labels) + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "max_surge", max_surge) + pulumi.set(__self__, "max_unavailable", max_unavailable) + pulumi.set(__self__, "maximum", maximum) + pulumi.set(__self__, "minimum", minimum) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "os_name", os_name) + pulumi.set(__self__, "os_version", os_version) + pulumi.set(__self__, "os_version_min", os_version_min) + pulumi.set(__self__, "os_version_used", os_version_used) + pulumi.set(__self__, "taints", taints) + pulumi.set(__self__, "volume_size", volume_size) + pulumi.set(__self__, "volume_type", volume_type) + + @property + @pulumi.getter(name="allowSystemComponents") + def allow_system_components(self) -> builtins.bool: + """ + Allow system components to run on this node pool. + """ + return pulumi.get(self, "allow_system_components") + + @property + @pulumi.getter(name="availabilityZones") + def availability_zones(self) -> Sequence[builtins.str]: + """ + Specify a list of availability zones. + """ + return pulumi.get(self, "availability_zones") + + @property + @pulumi.getter + def cri(self) -> builtins.str: + """ + Specifies the container runtime. + """ + return pulumi.get(self, "cri") + + @property + @pulumi.getter + def labels(self) -> Mapping[str, builtins.str]: + """ + Labels to add to each node. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> builtins.str: + """ + The machine type. + """ + return pulumi.get(self, "machine_type") + + @property + @pulumi.getter(name="maxSurge") + def max_surge(self) -> builtins.int: + """ + The maximum number of nodes upgraded simultaneously. + """ + return pulumi.get(self, "max_surge") + + @property + @pulumi.getter(name="maxUnavailable") + def max_unavailable(self) -> builtins.int: + """ + The maximum number of nodes unavailable during upgraded. + """ + return pulumi.get(self, "max_unavailable") + + @property + @pulumi.getter + def maximum(self) -> builtins.int: + """ + Maximum number of nodes in the pool. + """ + return pulumi.get(self, "maximum") + + @property + @pulumi.getter + def minimum(self) -> builtins.int: + """ + Minimum number of nodes in the pool. + """ + return pulumi.get(self, "minimum") + + @property + @pulumi.getter + def name(self) -> builtins.str: + """ + Specifies the name of the node pool. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="osName") + def os_name(self) -> builtins.str: + """ + The name of the OS image. + """ + return pulumi.get(self, "os_name") + + @property + @pulumi.getter(name="osVersion") + def os_version(self) -> builtins.str: + """ + The OS image version. + """ + return pulumi.get(self, "os_version") + + @property + @pulumi.getter(name="osVersionMin") + def os_version_min(self) -> builtins.str: + """ + The minimum OS image version, this field is always nil. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current OS image version being used for the node pool, use the read-only `os_version_used` field. + """ + return pulumi.get(self, "os_version_min") + + @property + @pulumi.getter(name="osVersionUsed") + def os_version_used(self) -> builtins.str: + """ + Full OS image version used. For example, if 3815.2 was set in `os_version_min`, this value may result to 3815.2.2. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "os_version_used") + + @property + @pulumi.getter + def taints(self) -> Sequence['outputs.GetSkeClusterNodePoolTaintResult']: + """ + Specifies a taint list as defined below. + """ + return pulumi.get(self, "taints") + + @property + @pulumi.getter(name="volumeSize") + def volume_size(self) -> builtins.int: + """ + The volume size in GB. + """ + return pulumi.get(self, "volume_size") + + @property + @pulumi.getter(name="volumeType") + def volume_type(self) -> builtins.str: + """ + Specifies the volume type. + """ + return pulumi.get(self, "volume_type") + + +@pulumi.output_type +class GetSkeClusterNodePoolTaintResult(dict): + def __init__(__self__, *, + effect: builtins.str, + key: builtins.str, + value: builtins.str): + """ + :param builtins.str effect: The taint effect. + :param builtins.str key: Taint key to be applied to a node. + :param builtins.str value: Taint value corresponding to the taint key. + """ + pulumi.set(__self__, "effect", effect) + pulumi.set(__self__, "key", key) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def effect(self) -> builtins.str: + """ + The taint effect. + """ + return pulumi.get(self, "effect") + + @property + @pulumi.getter + def key(self) -> builtins.str: + """ + Taint key to be applied to a node. + """ + return pulumi.get(self, "key") + + @property + @pulumi.getter + def value(self) -> builtins.str: + """ + Taint value corresponding to the taint key. + """ + return pulumi.get(self, "value") + + +@pulumi.output_type +class GetSqlserverflexInstanceFlavorResult(dict): + def __init__(__self__, *, + cpu: builtins.int, + description: builtins.str, + id: builtins.str, + ram: builtins.int): + pulumi.set(__self__, "cpu", cpu) + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "ram", ram) + + @property + @pulumi.getter + def cpu(self) -> builtins.int: + return pulumi.get(self, "cpu") + + @property + @pulumi.getter + def description(self) -> builtins.str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> builtins.str: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def ram(self) -> builtins.int: + return pulumi.get(self, "ram") + + +@pulumi.output_type +class GetSqlserverflexInstanceOptionsResult(dict): + def __init__(__self__, *, + edition: builtins.str, + retention_days: builtins.int): + pulumi.set(__self__, "edition", edition) + pulumi.set(__self__, "retention_days", retention_days) + + @property + @pulumi.getter + def edition(self) -> builtins.str: + return pulumi.get(self, "edition") + + @property + @pulumi.getter(name="retentionDays") + def retention_days(self) -> builtins.int: + return pulumi.get(self, "retention_days") + + +@pulumi.output_type +class GetSqlserverflexInstanceStorageResult(dict): + def __init__(__self__, *, + class_: builtins.str, + size: builtins.int): + pulumi.set(__self__, "class_", class_) + pulumi.set(__self__, "size", size) + + @property + @pulumi.getter(name="class") + def class_(self) -> builtins.str: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def size(self) -> builtins.int: + return pulumi.get(self, "size") + + +@pulumi.output_type +class GetVolumeSourceResult(dict): + def __init__(__self__, *, + id: builtins.str, + type: builtins.str): + """ + :param builtins.str id: The ID of the source, e.g. image ID + :param builtins.str type: The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "type", type) + + @property + @pulumi.getter + def id(self) -> builtins.str: + """ + The ID of the source, e.g. image ID + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def type(self) -> builtins.str: + """ + The type of the source. Supported values are: `volume`, `image`, `snapshot`, `backup`. + """ + return pulumi.get(self, "type") + + diff --git a/sdk/python/pulumi_stackit/postgresflex_database.py b/sdk/python/pulumi_stackit/postgresflex_database.py new file mode 100644 index 0000000..364e0d7 --- /dev/null +++ b/sdk/python/pulumi_stackit/postgresflex_database.py @@ -0,0 +1,375 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PostgresflexDatabaseArgs', 'PostgresflexDatabase'] + +@pulumi.input_type +class PostgresflexDatabaseArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + owner: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a PostgresflexDatabase resource. + :param pulumi.Input[builtins.str] instance_id: ID of the Postgres Flex instance. + :param pulumi.Input[builtins.str] owner: Username of the database owner. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] name: Database name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "owner", owner) + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the Postgres Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def owner(self) -> pulumi.Input[builtins.str]: + """ + Username of the database owner. + """ + return pulumi.get(self, "owner") + + @owner.setter + def owner(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "owner", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Database name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _PostgresflexDatabaseState: + def __init__(__self__, *, + database_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering PostgresflexDatabase resources. + :param pulumi.Input[builtins.str] database_id: Database ID. + :param pulumi.Input[builtins.str] instance_id: ID of the Postgres Flex instance. + :param pulumi.Input[builtins.str] name: Database name. + :param pulumi.Input[builtins.str] owner: Username of the database owner. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if database_id is not None: + pulumi.set(__self__, "database_id", database_id) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if owner is not None: + pulumi.set(__self__, "owner", owner) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="databaseId") + def database_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Database ID. + """ + return pulumi.get(self, "database_id") + + @database_id.setter + def database_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "database_id", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the Postgres Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Database name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def owner(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Username of the database owner. + """ + return pulumi.get(self, "owner") + + @owner.setter + def owner(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "owner", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.type_token("stackit:index/postgresflexDatabase:PostgresflexDatabase") +class PostgresflexDatabase(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the Postgres Flex instance. + :param pulumi.Input[builtins.str] name: Database name. + :param pulumi.Input[builtins.str] owner: Username of the database owner. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PostgresflexDatabaseArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Postgres Flex database resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param PostgresflexDatabaseArgs 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(PostgresflexDatabaseArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.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__ = PostgresflexDatabaseArgs.__new__(PostgresflexDatabaseArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + if owner is None and not opts.urn: + raise TypeError("Missing required property 'owner'") + __props__.__dict__["owner"] = owner + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["database_id"] = None + super(PostgresflexDatabase, __self__).__init__( + 'stackit:index/postgresflexDatabase:PostgresflexDatabase', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + database_id: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None) -> 'PostgresflexDatabase': + """ + Get an existing PostgresflexDatabase 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[builtins.str] database_id: Database ID. + :param pulumi.Input[builtins.str] instance_id: ID of the Postgres Flex instance. + :param pulumi.Input[builtins.str] name: Database name. + :param pulumi.Input[builtins.str] owner: Username of the database owner. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PostgresflexDatabaseState.__new__(_PostgresflexDatabaseState) + + __props__.__dict__["database_id"] = database_id + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["owner"] = owner + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + return PostgresflexDatabase(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="databaseId") + def database_id(self) -> pulumi.Output[builtins.str]: + """ + Database ID. + """ + return pulumi.get(self, "database_id") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the Postgres Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Database name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def owner(self) -> pulumi.Output[builtins.str]: + """ + Username of the database owner. + """ + return pulumi.get(self, "owner") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + diff --git a/sdk/python/pulumi_stackit/postgresflex_instance.py b/sdk/python/pulumi_stackit/postgresflex_instance.py new file mode 100644 index 0000000..625d7c7 --- /dev/null +++ b/sdk/python/pulumi_stackit/postgresflex_instance.py @@ -0,0 +1,504 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['PostgresflexInstanceArgs', 'PostgresflexInstance'] + +@pulumi.input_type +class PostgresflexInstanceArgs: + def __init__(__self__, *, + acls: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + backup_schedule: pulumi.Input[builtins.str], + flavor: pulumi.Input['PostgresflexInstanceFlavorArgs'], + project_id: pulumi.Input[builtins.str], + replicas: pulumi.Input[builtins.int], + storage: pulumi.Input['PostgresflexInstanceStorageArgs'], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a PostgresflexInstance resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the PostgresFlex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "acls", acls) + pulumi.set(__self__, "backup_schedule", backup_schedule) + pulumi.set(__self__, "flavor", flavor) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "replicas", replicas) + pulumi.set(__self__, "storage", storage) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter + def acls(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + The Access Control List (ACL) for the PostgresFlex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def flavor(self) -> pulumi.Input['PostgresflexInstanceFlavorArgs']: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: pulumi.Input['PostgresflexInstanceFlavorArgs']): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def replicas(self) -> pulumi.Input[builtins.int]: + return pulumi.get(self, "replicas") + + @replicas.setter + def replicas(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "replicas", value) + + @property + @pulumi.getter + def storage(self) -> pulumi.Input['PostgresflexInstanceStorageArgs']: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: pulumi.Input['PostgresflexInstanceStorageArgs']): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _PostgresflexInstanceState: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input['PostgresflexInstanceFlavorArgs']] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input['PostgresflexInstanceStorageArgs']] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering PostgresflexInstance resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the PostgresFlex instance. + :param pulumi.Input[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if backup_schedule is not None: + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor is not None: + pulumi.set(__self__, "flavor", flavor) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if replicas is not None: + pulumi.set(__self__, "replicas", replicas) + if storage is not None: + pulumi.set(__self__, "storage", storage) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The Access Control List (ACL) for the PostgresFlex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def flavor(self) -> Optional[pulumi.Input['PostgresflexInstanceFlavorArgs']]: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: Optional[pulumi.Input['PostgresflexInstanceFlavorArgs']]): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def replicas(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "replicas") + + @replicas.setter + def replicas(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "replicas", value) + + @property + @pulumi.getter + def storage(self) -> Optional[pulumi.Input['PostgresflexInstanceStorageArgs']]: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: Optional[pulumi.Input['PostgresflexInstanceStorageArgs']]): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/postgresflexInstance:PostgresflexInstance") +class PostgresflexInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['PostgresflexInstanceFlavorArgs', 'PostgresflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['PostgresflexInstanceStorageArgs', 'PostgresflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the PostgresFlex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PostgresflexInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Postgres Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param PostgresflexInstanceArgs 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(PostgresflexInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['PostgresflexInstanceFlavorArgs', 'PostgresflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['PostgresflexInstanceStorageArgs', 'PostgresflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.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__ = PostgresflexInstanceArgs.__new__(PostgresflexInstanceArgs) + + if acls is None and not opts.urn: + raise TypeError("Missing required property 'acls'") + __props__.__dict__["acls"] = acls + if backup_schedule is None and not opts.urn: + raise TypeError("Missing required property 'backup_schedule'") + __props__.__dict__["backup_schedule"] = backup_schedule + if flavor is None and not opts.urn: + raise TypeError("Missing required property 'flavor'") + __props__.__dict__["flavor"] = flavor + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if replicas is None and not opts.urn: + raise TypeError("Missing required property 'replicas'") + __props__.__dict__["replicas"] = replicas + if storage is None and not opts.urn: + raise TypeError("Missing required property 'storage'") + __props__.__dict__["storage"] = storage + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["instance_id"] = None + super(PostgresflexInstance, __self__).__init__( + 'stackit:index/postgresflexInstance:PostgresflexInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['PostgresflexInstanceFlavorArgs', 'PostgresflexInstanceFlavorArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['PostgresflexInstanceStorageArgs', 'PostgresflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'PostgresflexInstance': + """ + Get an existing PostgresflexInstance 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[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the PostgresFlex instance. + :param pulumi.Input[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PostgresflexInstanceState.__new__(_PostgresflexInstanceState) + + __props__.__dict__["acls"] = acls + __props__.__dict__["backup_schedule"] = backup_schedule + __props__.__dict__["flavor"] = flavor + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["replicas"] = replicas + __props__.__dict__["storage"] = storage + __props__.__dict__["version"] = version + return PostgresflexInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acls(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The Access Control List (ACL) for the PostgresFlex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> pulumi.Output['outputs.PostgresflexInstanceFlavor']: + return pulumi.get(self, "flavor") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def replicas(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> pulumi.Output['outputs.PostgresflexInstanceStorage']: + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/postgresflex_user.py b/sdk/python/pulumi_stackit/postgresflex_user.py new file mode 100644 index 0000000..7669092 --- /dev/null +++ b/sdk/python/pulumi_stackit/postgresflex_user.py @@ -0,0 +1,445 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PostgresflexUserArgs', 'PostgresflexUser'] + +@pulumi.input_type +class PostgresflexUserArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + roles: pulumi.Input[Sequence[pulumi.Input[builtins.str]]], + username: pulumi.Input[builtins.str], + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a PostgresflexUser resource. + :param pulumi.Input[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Supported values are: `login`, `createdb`. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "roles", roles) + pulumi.set(__self__, "username", username) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def roles(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]: + """ + Database access levels for the user. Supported values are: `login`, `createdb`. + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter + def username(self) -> pulumi.Input[builtins.str]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "username", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _PostgresflexUserState: + def __init__(__self__, *, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering PostgresflexUser resources. + :param pulumi.Input[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Supported values are: `login`, `createdb`. + :param pulumi.Input[builtins.str] user_id: User ID. + """ + if host is not None: + pulumi.set(__self__, "host", host) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if roles is not None: + pulumi.set(__self__, "roles", roles) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Database access levels for the user. Supported values are: `login`, `createdb`. + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_id", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/postgresflexUser:PostgresflexUser") +class PostgresflexUser(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Postgres Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Supported values are: `login`, `createdb`. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PostgresflexUserArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Postgres Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param PostgresflexUserArgs 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(PostgresflexUserArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.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__ = PostgresflexUserArgs.__new__(PostgresflexUserArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if roles is None and not opts.urn: + raise TypeError("Missing required property 'roles'") + __props__.__dict__["roles"] = roles + if username is None and not opts.urn: + raise TypeError("Missing required property 'username'") + __props__.__dict__["username"] = username + __props__.__dict__["host"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["user_id"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(PostgresflexUser, __self__).__init__( + 'stackit:index/postgresflexUser:PostgresflexUser', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'PostgresflexUser': + """ + Get an existing PostgresflexUser 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[builtins.str] instance_id: ID of the PostgresFlex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. Supported values are: `login`, `createdb`. + :param pulumi.Input[builtins.str] user_id: User ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PostgresflexUserState.__new__(_PostgresflexUserState) + + __props__.__dict__["host"] = host + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["roles"] = roles + __props__.__dict__["uri"] = uri + __props__.__dict__["user_id"] = user_id + __props__.__dict__["username"] = username + return PostgresflexUser(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the PostgresFlex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def roles(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + Database access levels for the user. Supported values are: `login`, `createdb`. + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[builtins.str]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/provider.py b/sdk/python/pulumi_stackit/provider.py new file mode 100644 index 0000000..0a3bc56 --- /dev/null +++ b/sdk/python/pulumi_stackit/provider.py @@ -0,0 +1,1163 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ProviderArgs', 'Provider'] + +@pulumi.input_type +class ProviderArgs: + def __init__(__self__, *, + argus_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + authorization_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + cdn_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + credentials_path: Optional[pulumi.Input[builtins.str]] = None, + default_region: Optional[pulumi.Input[builtins.str]] = None, + dns_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + enable_beta_resources: Optional[pulumi.Input[builtins.bool]] = None, + experiments: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + git_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + iaas_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + loadbalancer_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + logme_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mariadb_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + modelserving_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mongodbflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + objectstorage_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + observability_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + opensearch_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + postgresflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + private_key: Optional[pulumi.Input[builtins.str]] = None, + private_key_path: Optional[pulumi.Input[builtins.str]] = None, + rabbitmq_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + redis_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + resourcemanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + secretsmanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_backup_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_update_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + service_account_key: Optional[pulumi.Input[builtins.str]] = None, + service_account_key_path: Optional[pulumi.Input[builtins.str]] = None, + service_account_token: Optional[pulumi.Input[builtins.str]] = None, + service_enablement_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + ske_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + sqlserverflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + token_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a Provider resource. + :param pulumi.Input[builtins.str] argus_custom_endpoint: Custom endpoint for the Argus service + :param pulumi.Input[builtins.str] authorization_custom_endpoint: Custom endpoint for the Membership service + :param pulumi.Input[builtins.str] cdn_custom_endpoint: Custom endpoint for the CDN service + :param pulumi.Input[builtins.str] credentials_path: Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + value is `~/.stackit/credentials.json`. + :param pulumi.Input[builtins.str] default_region: Region will be used as the default location for regional services. Not all services require a region, some are global + :param pulumi.Input[builtins.str] dns_custom_endpoint: Custom endpoint for the DNS service + :param pulumi.Input[builtins.bool] enable_beta_resources: Enable beta resources. Default is false. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] experiments: Enables experiments. These are unstable features without official support. More information can be found in the README. + Available Experiments: [iam] + :param pulumi.Input[builtins.str] git_custom_endpoint: Custom endpoint for the Git service + :param pulumi.Input[builtins.str] iaas_custom_endpoint: Custom endpoint for the IaaS service + :param pulumi.Input[builtins.str] loadbalancer_custom_endpoint: Custom endpoint for the Load Balancer service + :param pulumi.Input[builtins.str] logme_custom_endpoint: Custom endpoint for the LogMe service + :param pulumi.Input[builtins.str] mariadb_custom_endpoint: Custom endpoint for the MariaDB service + :param pulumi.Input[builtins.str] modelserving_custom_endpoint: Custom endpoint for the AI Model Serving service + :param pulumi.Input[builtins.str] mongodbflex_custom_endpoint: Custom endpoint for the MongoDB Flex service + :param pulumi.Input[builtins.str] objectstorage_custom_endpoint: Custom endpoint for the Object Storage service + :param pulumi.Input[builtins.str] observability_custom_endpoint: Custom endpoint for the Observability service + :param pulumi.Input[builtins.str] opensearch_custom_endpoint: Custom endpoint for the OpenSearch service + :param pulumi.Input[builtins.str] postgresflex_custom_endpoint: Custom endpoint for the PostgresFlex service + :param pulumi.Input[builtins.str] private_key: Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + included in the service account key. + :param pulumi.Input[builtins.str] private_key_path: Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + key that is included in the service account key. + :param pulumi.Input[builtins.str] rabbitmq_custom_endpoint: Custom endpoint for the RabbitMQ service + :param pulumi.Input[builtins.str] redis_custom_endpoint: Custom endpoint for the Redis service + :param pulumi.Input[builtins.str] region: Region will be used as the default location for regional services. Not all services require a region, some are global + :param pulumi.Input[builtins.str] resourcemanager_custom_endpoint: Custom endpoint for the Resource Manager service + :param pulumi.Input[builtins.str] secretsmanager_custom_endpoint: Custom endpoint for the Secrets Manager service + :param pulumi.Input[builtins.str] server_backup_custom_endpoint: Custom endpoint for the Server Backup service + :param pulumi.Input[builtins.str] server_update_custom_endpoint: Custom endpoint for the Server Update service + :param pulumi.Input[builtins.str] service_account_custom_endpoint: Custom endpoint for the Service Account service + :param pulumi.Input[builtins.str] service_account_email: Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + if you want to use the resource manager project resource. + :param pulumi.Input[builtins.str] service_account_key: Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + :param pulumi.Input[builtins.str] service_account_key_path: Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + operations. + :param pulumi.Input[builtins.str] service_account_token: Token used for authentication. If set, the token flow will be used to authenticate all operations. + :param pulumi.Input[builtins.str] service_enablement_custom_endpoint: Custom endpoint for the Service Enablement API + :param pulumi.Input[builtins.str] ske_custom_endpoint: Custom endpoint for the Kubernetes Engine (SKE) service + :param pulumi.Input[builtins.str] sqlserverflex_custom_endpoint: Custom endpoint for the SQL Server Flex service + :param pulumi.Input[builtins.str] token_custom_endpoint: Custom endpoint for the token API, which is used to request access tokens when using the key flow + """ + if argus_custom_endpoint is not None: + warnings.warn("""Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality.""", DeprecationWarning) + pulumi.log.warn("""argus_custom_endpoint is deprecated: Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality.""") + if argus_custom_endpoint is not None: + pulumi.set(__self__, "argus_custom_endpoint", argus_custom_endpoint) + if authorization_custom_endpoint is not None: + pulumi.set(__self__, "authorization_custom_endpoint", authorization_custom_endpoint) + if cdn_custom_endpoint is not None: + pulumi.set(__self__, "cdn_custom_endpoint", cdn_custom_endpoint) + if credentials_path is not None: + pulumi.set(__self__, "credentials_path", credentials_path) + if default_region is not None: + pulumi.set(__self__, "default_region", default_region) + if dns_custom_endpoint is not None: + pulumi.set(__self__, "dns_custom_endpoint", dns_custom_endpoint) + if enable_beta_resources is not None: + pulumi.set(__self__, "enable_beta_resources", enable_beta_resources) + if experiments is not None: + pulumi.set(__self__, "experiments", experiments) + if git_custom_endpoint is not None: + pulumi.set(__self__, "git_custom_endpoint", git_custom_endpoint) + if iaas_custom_endpoint is not None: + pulumi.set(__self__, "iaas_custom_endpoint", iaas_custom_endpoint) + if loadbalancer_custom_endpoint is not None: + pulumi.set(__self__, "loadbalancer_custom_endpoint", loadbalancer_custom_endpoint) + if logme_custom_endpoint is not None: + pulumi.set(__self__, "logme_custom_endpoint", logme_custom_endpoint) + if mariadb_custom_endpoint is not None: + pulumi.set(__self__, "mariadb_custom_endpoint", mariadb_custom_endpoint) + if modelserving_custom_endpoint is not None: + pulumi.set(__self__, "modelserving_custom_endpoint", modelserving_custom_endpoint) + if mongodbflex_custom_endpoint is not None: + pulumi.set(__self__, "mongodbflex_custom_endpoint", mongodbflex_custom_endpoint) + if objectstorage_custom_endpoint is not None: + pulumi.set(__self__, "objectstorage_custom_endpoint", objectstorage_custom_endpoint) + if observability_custom_endpoint is not None: + pulumi.set(__self__, "observability_custom_endpoint", observability_custom_endpoint) + if opensearch_custom_endpoint is not None: + pulumi.set(__self__, "opensearch_custom_endpoint", opensearch_custom_endpoint) + if postgresflex_custom_endpoint is not None: + pulumi.set(__self__, "postgresflex_custom_endpoint", postgresflex_custom_endpoint) + if private_key is not None: + pulumi.set(__self__, "private_key", private_key) + if private_key_path is not None: + pulumi.set(__self__, "private_key_path", private_key_path) + if rabbitmq_custom_endpoint is not None: + pulumi.set(__self__, "rabbitmq_custom_endpoint", rabbitmq_custom_endpoint) + if redis_custom_endpoint is not None: + pulumi.set(__self__, "redis_custom_endpoint", redis_custom_endpoint) + if region is not None: + warnings.warn("""This attribute is deprecated. Use 'default_region' instead""", DeprecationWarning) + pulumi.log.warn("""region is deprecated: This attribute is deprecated. Use 'default_region' instead""") + if region is not None: + pulumi.set(__self__, "region", region) + if resourcemanager_custom_endpoint is not None: + pulumi.set(__self__, "resourcemanager_custom_endpoint", resourcemanager_custom_endpoint) + if secretsmanager_custom_endpoint is not None: + pulumi.set(__self__, "secretsmanager_custom_endpoint", secretsmanager_custom_endpoint) + if server_backup_custom_endpoint is not None: + pulumi.set(__self__, "server_backup_custom_endpoint", server_backup_custom_endpoint) + if server_update_custom_endpoint is not None: + pulumi.set(__self__, "server_update_custom_endpoint", server_update_custom_endpoint) + if service_account_custom_endpoint is not None: + pulumi.set(__self__, "service_account_custom_endpoint", service_account_custom_endpoint) + if service_account_email is not None: + warnings.warn("""The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025.""", DeprecationWarning) + pulumi.log.warn("""service_account_email is deprecated: The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025.""") + if service_account_email is not None: + pulumi.set(__self__, "service_account_email", service_account_email) + if service_account_key is not None: + pulumi.set(__self__, "service_account_key", service_account_key) + if service_account_key_path is not None: + pulumi.set(__self__, "service_account_key_path", service_account_key_path) + if service_account_token is not None: + pulumi.set(__self__, "service_account_token", service_account_token) + if service_enablement_custom_endpoint is not None: + pulumi.set(__self__, "service_enablement_custom_endpoint", service_enablement_custom_endpoint) + if ske_custom_endpoint is not None: + pulumi.set(__self__, "ske_custom_endpoint", ske_custom_endpoint) + if sqlserverflex_custom_endpoint is not None: + pulumi.set(__self__, "sqlserverflex_custom_endpoint", sqlserverflex_custom_endpoint) + if token_custom_endpoint is not None: + pulumi.set(__self__, "token_custom_endpoint", token_custom_endpoint) + + @property + @pulumi.getter(name="argusCustomEndpoint") + @_utilities.deprecated("""Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality.""") + def argus_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Argus service + """ + return pulumi.get(self, "argus_custom_endpoint") + + @argus_custom_endpoint.setter + def argus_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "argus_custom_endpoint", value) + + @property + @pulumi.getter(name="authorizationCustomEndpoint") + def authorization_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Membership service + """ + return pulumi.get(self, "authorization_custom_endpoint") + + @authorization_custom_endpoint.setter + def authorization_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "authorization_custom_endpoint", value) + + @property + @pulumi.getter(name="cdnCustomEndpoint") + def cdn_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the CDN service + """ + return pulumi.get(self, "cdn_custom_endpoint") + + @cdn_custom_endpoint.setter + def cdn_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cdn_custom_endpoint", value) + + @property + @pulumi.getter(name="credentialsPath") + def credentials_path(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + value is `~/.stackit/credentials.json`. + """ + return pulumi.get(self, "credentials_path") + + @credentials_path.setter + def credentials_path(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credentials_path", value) + + @property + @pulumi.getter(name="defaultRegion") + def default_region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return pulumi.get(self, "default_region") + + @default_region.setter + def default_region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "default_region", value) + + @property + @pulumi.getter(name="dnsCustomEndpoint") + def dns_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the DNS service + """ + return pulumi.get(self, "dns_custom_endpoint") + + @dns_custom_endpoint.setter + def dns_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dns_custom_endpoint", value) + + @property + @pulumi.getter(name="enableBetaResources") + def enable_beta_resources(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Enable beta resources. Default is false. + """ + return pulumi.get(self, "enable_beta_resources") + + @enable_beta_resources.setter + def enable_beta_resources(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enable_beta_resources", value) + + @property + @pulumi.getter + def experiments(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Enables experiments. These are unstable features without official support. More information can be found in the README. + Available Experiments: [iam] + """ + return pulumi.get(self, "experiments") + + @experiments.setter + def experiments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "experiments", value) + + @property + @pulumi.getter(name="gitCustomEndpoint") + def git_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Git service + """ + return pulumi.get(self, "git_custom_endpoint") + + @git_custom_endpoint.setter + def git_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "git_custom_endpoint", value) + + @property + @pulumi.getter(name="iaasCustomEndpoint") + def iaas_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the IaaS service + """ + return pulumi.get(self, "iaas_custom_endpoint") + + @iaas_custom_endpoint.setter + def iaas_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "iaas_custom_endpoint", value) + + @property + @pulumi.getter(name="loadbalancerCustomEndpoint") + def loadbalancer_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Load Balancer service + """ + return pulumi.get(self, "loadbalancer_custom_endpoint") + + @loadbalancer_custom_endpoint.setter + def loadbalancer_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "loadbalancer_custom_endpoint", value) + + @property + @pulumi.getter(name="logmeCustomEndpoint") + def logme_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the LogMe service + """ + return pulumi.get(self, "logme_custom_endpoint") + + @logme_custom_endpoint.setter + def logme_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "logme_custom_endpoint", value) + + @property + @pulumi.getter(name="mariadbCustomEndpoint") + def mariadb_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the MariaDB service + """ + return pulumi.get(self, "mariadb_custom_endpoint") + + @mariadb_custom_endpoint.setter + def mariadb_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "mariadb_custom_endpoint", value) + + @property + @pulumi.getter(name="modelservingCustomEndpoint") + def modelserving_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the AI Model Serving service + """ + return pulumi.get(self, "modelserving_custom_endpoint") + + @modelserving_custom_endpoint.setter + def modelserving_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "modelserving_custom_endpoint", value) + + @property + @pulumi.getter(name="mongodbflexCustomEndpoint") + def mongodbflex_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the MongoDB Flex service + """ + return pulumi.get(self, "mongodbflex_custom_endpoint") + + @mongodbflex_custom_endpoint.setter + def mongodbflex_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "mongodbflex_custom_endpoint", value) + + @property + @pulumi.getter(name="objectstorageCustomEndpoint") + def objectstorage_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Object Storage service + """ + return pulumi.get(self, "objectstorage_custom_endpoint") + + @objectstorage_custom_endpoint.setter + def objectstorage_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "objectstorage_custom_endpoint", value) + + @property + @pulumi.getter(name="observabilityCustomEndpoint") + def observability_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Observability service + """ + return pulumi.get(self, "observability_custom_endpoint") + + @observability_custom_endpoint.setter + def observability_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "observability_custom_endpoint", value) + + @property + @pulumi.getter(name="opensearchCustomEndpoint") + def opensearch_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the OpenSearch service + """ + return pulumi.get(self, "opensearch_custom_endpoint") + + @opensearch_custom_endpoint.setter + def opensearch_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "opensearch_custom_endpoint", value) + + @property + @pulumi.getter(name="postgresflexCustomEndpoint") + def postgresflex_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the PostgresFlex service + """ + return pulumi.get(self, "postgresflex_custom_endpoint") + + @postgresflex_custom_endpoint.setter + def postgresflex_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "postgresflex_custom_endpoint", value) + + @property + @pulumi.getter(name="privateKey") + def private_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + included in the service account key. + """ + return pulumi.get(self, "private_key") + + @private_key.setter + def private_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "private_key", value) + + @property + @pulumi.getter(name="privateKeyPath") + def private_key_path(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + key that is included in the service account key. + """ + return pulumi.get(self, "private_key_path") + + @private_key_path.setter + def private_key_path(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "private_key_path", value) + + @property + @pulumi.getter(name="rabbitmqCustomEndpoint") + def rabbitmq_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the RabbitMQ service + """ + return pulumi.get(self, "rabbitmq_custom_endpoint") + + @rabbitmq_custom_endpoint.setter + def rabbitmq_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "rabbitmq_custom_endpoint", value) + + @property + @pulumi.getter(name="redisCustomEndpoint") + def redis_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Redis service + """ + return pulumi.get(self, "redis_custom_endpoint") + + @redis_custom_endpoint.setter + def redis_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "redis_custom_endpoint", value) + + @property + @pulumi.getter + @_utilities.deprecated("""This attribute is deprecated. Use 'default_region' instead""") + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="resourcemanagerCustomEndpoint") + def resourcemanager_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Resource Manager service + """ + return pulumi.get(self, "resourcemanager_custom_endpoint") + + @resourcemanager_custom_endpoint.setter + def resourcemanager_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "resourcemanager_custom_endpoint", value) + + @property + @pulumi.getter(name="secretsmanagerCustomEndpoint") + def secretsmanager_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Secrets Manager service + """ + return pulumi.get(self, "secretsmanager_custom_endpoint") + + @secretsmanager_custom_endpoint.setter + def secretsmanager_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "secretsmanager_custom_endpoint", value) + + @property + @pulumi.getter(name="serverBackupCustomEndpoint") + def server_backup_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Server Backup service + """ + return pulumi.get(self, "server_backup_custom_endpoint") + + @server_backup_custom_endpoint.setter + def server_backup_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_backup_custom_endpoint", value) + + @property + @pulumi.getter(name="serverUpdateCustomEndpoint") + def server_update_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Server Update service + """ + return pulumi.get(self, "server_update_custom_endpoint") + + @server_update_custom_endpoint.setter + def server_update_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_update_custom_endpoint", value) + + @property + @pulumi.getter(name="serviceAccountCustomEndpoint") + def service_account_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Service Account service + """ + return pulumi.get(self, "service_account_custom_endpoint") + + @service_account_custom_endpoint.setter + def service_account_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_custom_endpoint", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + @_utilities.deprecated("""The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025.""") + def service_account_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + if you want to use the resource manager project resource. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_email", value) + + @property + @pulumi.getter(name="serviceAccountKey") + def service_account_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + """ + return pulumi.get(self, "service_account_key") + + @service_account_key.setter + def service_account_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_key", value) + + @property + @pulumi.getter(name="serviceAccountKeyPath") + def service_account_key_path(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + operations. + """ + return pulumi.get(self, "service_account_key_path") + + @service_account_key_path.setter + def service_account_key_path(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_key_path", value) + + @property + @pulumi.getter(name="serviceAccountToken") + def service_account_token(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Token used for authentication. If set, the token flow will be used to authenticate all operations. + """ + return pulumi.get(self, "service_account_token") + + @service_account_token.setter + def service_account_token(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_token", value) + + @property + @pulumi.getter(name="serviceEnablementCustomEndpoint") + def service_enablement_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Service Enablement API + """ + return pulumi.get(self, "service_enablement_custom_endpoint") + + @service_enablement_custom_endpoint.setter + def service_enablement_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_enablement_custom_endpoint", value) + + @property + @pulumi.getter(name="skeCustomEndpoint") + def ske_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the Kubernetes Engine (SKE) service + """ + return pulumi.get(self, "ske_custom_endpoint") + + @ske_custom_endpoint.setter + def ske_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ske_custom_endpoint", value) + + @property + @pulumi.getter(name="sqlserverflexCustomEndpoint") + def sqlserverflex_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the SQL Server Flex service + """ + return pulumi.get(self, "sqlserverflex_custom_endpoint") + + @sqlserverflex_custom_endpoint.setter + def sqlserverflex_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "sqlserverflex_custom_endpoint", value) + + @property + @pulumi.getter(name="tokenCustomEndpoint") + def token_custom_endpoint(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Custom endpoint for the token API, which is used to request access tokens when using the key flow + """ + return pulumi.get(self, "token_custom_endpoint") + + @token_custom_endpoint.setter + def token_custom_endpoint(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "token_custom_endpoint", value) + + +@pulumi.type_token("pulumi:providers:stackit") +class Provider(pulumi.ProviderResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + argus_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + authorization_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + cdn_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + credentials_path: Optional[pulumi.Input[builtins.str]] = None, + default_region: Optional[pulumi.Input[builtins.str]] = None, + dns_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + enable_beta_resources: Optional[pulumi.Input[builtins.bool]] = None, + experiments: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + git_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + iaas_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + loadbalancer_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + logme_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mariadb_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + modelserving_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mongodbflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + objectstorage_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + observability_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + opensearch_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + postgresflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + private_key: Optional[pulumi.Input[builtins.str]] = None, + private_key_path: Optional[pulumi.Input[builtins.str]] = None, + rabbitmq_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + redis_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + resourcemanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + secretsmanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_backup_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_update_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + service_account_key: Optional[pulumi.Input[builtins.str]] = None, + service_account_key_path: Optional[pulumi.Input[builtins.str]] = None, + service_account_token: Optional[pulumi.Input[builtins.str]] = None, + service_enablement_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + ske_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + sqlserverflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + token_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + The provider type for the stackit package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] argus_custom_endpoint: Custom endpoint for the Argus service + :param pulumi.Input[builtins.str] authorization_custom_endpoint: Custom endpoint for the Membership service + :param pulumi.Input[builtins.str] cdn_custom_endpoint: Custom endpoint for the CDN service + :param pulumi.Input[builtins.str] credentials_path: Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + value is `~/.stackit/credentials.json`. + :param pulumi.Input[builtins.str] default_region: Region will be used as the default location for regional services. Not all services require a region, some are global + :param pulumi.Input[builtins.str] dns_custom_endpoint: Custom endpoint for the DNS service + :param pulumi.Input[builtins.bool] enable_beta_resources: Enable beta resources. Default is false. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] experiments: Enables experiments. These are unstable features without official support. More information can be found in the README. + Available Experiments: [iam] + :param pulumi.Input[builtins.str] git_custom_endpoint: Custom endpoint for the Git service + :param pulumi.Input[builtins.str] iaas_custom_endpoint: Custom endpoint for the IaaS service + :param pulumi.Input[builtins.str] loadbalancer_custom_endpoint: Custom endpoint for the Load Balancer service + :param pulumi.Input[builtins.str] logme_custom_endpoint: Custom endpoint for the LogMe service + :param pulumi.Input[builtins.str] mariadb_custom_endpoint: Custom endpoint for the MariaDB service + :param pulumi.Input[builtins.str] modelserving_custom_endpoint: Custom endpoint for the AI Model Serving service + :param pulumi.Input[builtins.str] mongodbflex_custom_endpoint: Custom endpoint for the MongoDB Flex service + :param pulumi.Input[builtins.str] objectstorage_custom_endpoint: Custom endpoint for the Object Storage service + :param pulumi.Input[builtins.str] observability_custom_endpoint: Custom endpoint for the Observability service + :param pulumi.Input[builtins.str] opensearch_custom_endpoint: Custom endpoint for the OpenSearch service + :param pulumi.Input[builtins.str] postgresflex_custom_endpoint: Custom endpoint for the PostgresFlex service + :param pulumi.Input[builtins.str] private_key: Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + included in the service account key. + :param pulumi.Input[builtins.str] private_key_path: Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + key that is included in the service account key. + :param pulumi.Input[builtins.str] rabbitmq_custom_endpoint: Custom endpoint for the RabbitMQ service + :param pulumi.Input[builtins.str] redis_custom_endpoint: Custom endpoint for the Redis service + :param pulumi.Input[builtins.str] region: Region will be used as the default location for regional services. Not all services require a region, some are global + :param pulumi.Input[builtins.str] resourcemanager_custom_endpoint: Custom endpoint for the Resource Manager service + :param pulumi.Input[builtins.str] secretsmanager_custom_endpoint: Custom endpoint for the Secrets Manager service + :param pulumi.Input[builtins.str] server_backup_custom_endpoint: Custom endpoint for the Server Backup service + :param pulumi.Input[builtins.str] server_update_custom_endpoint: Custom endpoint for the Server Update service + :param pulumi.Input[builtins.str] service_account_custom_endpoint: Custom endpoint for the Service Account service + :param pulumi.Input[builtins.str] service_account_email: Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + if you want to use the resource manager project resource. + :param pulumi.Input[builtins.str] service_account_key: Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + :param pulumi.Input[builtins.str] service_account_key_path: Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + operations. + :param pulumi.Input[builtins.str] service_account_token: Token used for authentication. If set, the token flow will be used to authenticate all operations. + :param pulumi.Input[builtins.str] service_enablement_custom_endpoint: Custom endpoint for the Service Enablement API + :param pulumi.Input[builtins.str] ske_custom_endpoint: Custom endpoint for the Kubernetes Engine (SKE) service + :param pulumi.Input[builtins.str] sqlserverflex_custom_endpoint: Custom endpoint for the SQL Server Flex service + :param pulumi.Input[builtins.str] token_custom_endpoint: Custom endpoint for the token API, which is used to request access tokens when using the key flow + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[ProviderArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + The provider type for the stackit package. By default, resources use package-wide configuration + settings, however an explicit `Provider` instance may be created and passed during resource + construction to achieve fine-grained programmatic control over provider settings. See the + [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. + + :param str resource_name: The name of the resource. + :param ProviderArgs 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(ProviderArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + argus_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + authorization_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + cdn_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + credentials_path: Optional[pulumi.Input[builtins.str]] = None, + default_region: Optional[pulumi.Input[builtins.str]] = None, + dns_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + enable_beta_resources: Optional[pulumi.Input[builtins.bool]] = None, + experiments: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + git_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + iaas_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + loadbalancer_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + logme_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mariadb_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + modelserving_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + mongodbflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + objectstorage_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + observability_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + opensearch_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + postgresflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + private_key: Optional[pulumi.Input[builtins.str]] = None, + private_key_path: Optional[pulumi.Input[builtins.str]] = None, + rabbitmq_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + redis_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + resourcemanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + secretsmanager_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_backup_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + server_update_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + service_account_key: Optional[pulumi.Input[builtins.str]] = None, + service_account_key_path: Optional[pulumi.Input[builtins.str]] = None, + service_account_token: Optional[pulumi.Input[builtins.str]] = None, + service_enablement_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + ske_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + sqlserverflex_custom_endpoint: Optional[pulumi.Input[builtins.str]] = None, + token_custom_endpoint: Optional[pulumi.Input[builtins.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__ = ProviderArgs.__new__(ProviderArgs) + + __props__.__dict__["argus_custom_endpoint"] = argus_custom_endpoint + __props__.__dict__["authorization_custom_endpoint"] = authorization_custom_endpoint + __props__.__dict__["cdn_custom_endpoint"] = cdn_custom_endpoint + __props__.__dict__["credentials_path"] = credentials_path + __props__.__dict__["default_region"] = default_region + __props__.__dict__["dns_custom_endpoint"] = dns_custom_endpoint + __props__.__dict__["enable_beta_resources"] = pulumi.Output.from_input(enable_beta_resources).apply(pulumi.runtime.to_json) if enable_beta_resources is not None else None + __props__.__dict__["experiments"] = pulumi.Output.from_input(experiments).apply(pulumi.runtime.to_json) if experiments is not None else None + __props__.__dict__["git_custom_endpoint"] = git_custom_endpoint + __props__.__dict__["iaas_custom_endpoint"] = iaas_custom_endpoint + __props__.__dict__["loadbalancer_custom_endpoint"] = loadbalancer_custom_endpoint + __props__.__dict__["logme_custom_endpoint"] = logme_custom_endpoint + __props__.__dict__["mariadb_custom_endpoint"] = mariadb_custom_endpoint + __props__.__dict__["modelserving_custom_endpoint"] = modelserving_custom_endpoint + __props__.__dict__["mongodbflex_custom_endpoint"] = mongodbflex_custom_endpoint + __props__.__dict__["objectstorage_custom_endpoint"] = objectstorage_custom_endpoint + __props__.__dict__["observability_custom_endpoint"] = observability_custom_endpoint + __props__.__dict__["opensearch_custom_endpoint"] = opensearch_custom_endpoint + __props__.__dict__["postgresflex_custom_endpoint"] = postgresflex_custom_endpoint + __props__.__dict__["private_key"] = private_key + __props__.__dict__["private_key_path"] = private_key_path + __props__.__dict__["rabbitmq_custom_endpoint"] = rabbitmq_custom_endpoint + __props__.__dict__["redis_custom_endpoint"] = redis_custom_endpoint + __props__.__dict__["region"] = region + __props__.__dict__["resourcemanager_custom_endpoint"] = resourcemanager_custom_endpoint + __props__.__dict__["secretsmanager_custom_endpoint"] = secretsmanager_custom_endpoint + __props__.__dict__["server_backup_custom_endpoint"] = server_backup_custom_endpoint + __props__.__dict__["server_update_custom_endpoint"] = server_update_custom_endpoint + __props__.__dict__["service_account_custom_endpoint"] = service_account_custom_endpoint + __props__.__dict__["service_account_email"] = service_account_email + __props__.__dict__["service_account_key"] = service_account_key + __props__.__dict__["service_account_key_path"] = service_account_key_path + __props__.__dict__["service_account_token"] = service_account_token + __props__.__dict__["service_enablement_custom_endpoint"] = service_enablement_custom_endpoint + __props__.__dict__["ske_custom_endpoint"] = ske_custom_endpoint + __props__.__dict__["sqlserverflex_custom_endpoint"] = sqlserverflex_custom_endpoint + __props__.__dict__["token_custom_endpoint"] = token_custom_endpoint + super(Provider, __self__).__init__( + 'stackit', + resource_name, + __props__, + opts) + + @property + @pulumi.getter(name="argusCustomEndpoint") + @_utilities.deprecated("""Argus service has been deprecated and integration will be removed after February 26th 2025. Please use `observability_custom_endpoint` and `observability` resources instead, which offer the exact same functionality.""") + def argus_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Argus service + """ + return pulumi.get(self, "argus_custom_endpoint") + + @property + @pulumi.getter(name="authorizationCustomEndpoint") + def authorization_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Membership service + """ + return pulumi.get(self, "authorization_custom_endpoint") + + @property + @pulumi.getter(name="cdnCustomEndpoint") + def cdn_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the CDN service + """ + return pulumi.get(self, "cdn_custom_endpoint") + + @property + @pulumi.getter(name="credentialsPath") + def credentials_path(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Path of JSON from where the credentials are read. Takes precedence over the env var `STACKIT_CREDENTIALS_PATH`. Default + value is `~/.stackit/credentials.json`. + """ + return pulumi.get(self, "credentials_path") + + @property + @pulumi.getter(name="defaultRegion") + def default_region(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return pulumi.get(self, "default_region") + + @property + @pulumi.getter(name="dnsCustomEndpoint") + def dns_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the DNS service + """ + return pulumi.get(self, "dns_custom_endpoint") + + @property + @pulumi.getter(name="gitCustomEndpoint") + def git_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Git service + """ + return pulumi.get(self, "git_custom_endpoint") + + @property + @pulumi.getter(name="iaasCustomEndpoint") + def iaas_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the IaaS service + """ + return pulumi.get(self, "iaas_custom_endpoint") + + @property + @pulumi.getter(name="loadbalancerCustomEndpoint") + def loadbalancer_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Load Balancer service + """ + return pulumi.get(self, "loadbalancer_custom_endpoint") + + @property + @pulumi.getter(name="logmeCustomEndpoint") + def logme_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the LogMe service + """ + return pulumi.get(self, "logme_custom_endpoint") + + @property + @pulumi.getter(name="mariadbCustomEndpoint") + def mariadb_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the MariaDB service + """ + return pulumi.get(self, "mariadb_custom_endpoint") + + @property + @pulumi.getter(name="modelservingCustomEndpoint") + def modelserving_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the AI Model Serving service + """ + return pulumi.get(self, "modelserving_custom_endpoint") + + @property + @pulumi.getter(name="mongodbflexCustomEndpoint") + def mongodbflex_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the MongoDB Flex service + """ + return pulumi.get(self, "mongodbflex_custom_endpoint") + + @property + @pulumi.getter(name="objectstorageCustomEndpoint") + def objectstorage_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Object Storage service + """ + return pulumi.get(self, "objectstorage_custom_endpoint") + + @property + @pulumi.getter(name="observabilityCustomEndpoint") + def observability_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Observability service + """ + return pulumi.get(self, "observability_custom_endpoint") + + @property + @pulumi.getter(name="opensearchCustomEndpoint") + def opensearch_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the OpenSearch service + """ + return pulumi.get(self, "opensearch_custom_endpoint") + + @property + @pulumi.getter(name="postgresflexCustomEndpoint") + def postgresflex_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the PostgresFlex service + """ + return pulumi.get(self, "postgresflex_custom_endpoint") + + @property + @pulumi.getter(name="privateKey") + def private_key(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Private RSA key used for authentication, relevant for the key flow. It takes precedence over the private key that is + included in the service account key. + """ + return pulumi.get(self, "private_key") + + @property + @pulumi.getter(name="privateKeyPath") + def private_key_path(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Path for the private RSA key used for authentication, relevant for the key flow. It takes precedence over the private + key that is included in the service account key. + """ + return pulumi.get(self, "private_key_path") + + @property + @pulumi.getter(name="rabbitmqCustomEndpoint") + def rabbitmq_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the RabbitMQ service + """ + return pulumi.get(self, "rabbitmq_custom_endpoint") + + @property + @pulumi.getter(name="redisCustomEndpoint") + def redis_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Redis service + """ + return pulumi.get(self, "redis_custom_endpoint") + + @property + @pulumi.getter + @_utilities.deprecated("""This attribute is deprecated. Use 'default_region' instead""") + def region(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Region will be used as the default location for regional services. Not all services require a region, some are global + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="resourcemanagerCustomEndpoint") + def resourcemanager_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Resource Manager service + """ + return pulumi.get(self, "resourcemanager_custom_endpoint") + + @property + @pulumi.getter(name="secretsmanagerCustomEndpoint") + def secretsmanager_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Secrets Manager service + """ + return pulumi.get(self, "secretsmanager_custom_endpoint") + + @property + @pulumi.getter(name="serverBackupCustomEndpoint") + def server_backup_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Server Backup service + """ + return pulumi.get(self, "server_backup_custom_endpoint") + + @property + @pulumi.getter(name="serverUpdateCustomEndpoint") + def server_update_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Server Update service + """ + return pulumi.get(self, "server_update_custom_endpoint") + + @property + @pulumi.getter(name="serviceAccountCustomEndpoint") + def service_account_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Service Account service + """ + return pulumi.get(self, "service_account_custom_endpoint") + + @property + @pulumi.getter(name="serviceAccountEmail") + @_utilities.deprecated("""The `service_account_email` field has been deprecated because it is not required. Will be removed after June 12th 2025.""") + def service_account_email(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Service account email. It can also be set using the environment variable STACKIT_SERVICE_ACCOUNT_EMAIL. It is required + if you want to use the resource manager project resource. + """ + return pulumi.get(self, "service_account_email") + + @property + @pulumi.getter(name="serviceAccountKey") + def service_account_key(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Service account key used for authentication. If set, the key flow will be used to authenticate all operations. + """ + return pulumi.get(self, "service_account_key") + + @property + @pulumi.getter(name="serviceAccountKeyPath") + def service_account_key_path(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Path for the service account key used for authentication. If set, the key flow will be used to authenticate all + operations. + """ + return pulumi.get(self, "service_account_key_path") + + @property + @pulumi.getter(name="serviceAccountToken") + def service_account_token(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Token used for authentication. If set, the token flow will be used to authenticate all operations. + """ + return pulumi.get(self, "service_account_token") + + @property + @pulumi.getter(name="serviceEnablementCustomEndpoint") + def service_enablement_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Service Enablement API + """ + return pulumi.get(self, "service_enablement_custom_endpoint") + + @property + @pulumi.getter(name="skeCustomEndpoint") + def ske_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the Kubernetes Engine (SKE) service + """ + return pulumi.get(self, "ske_custom_endpoint") + + @property + @pulumi.getter(name="sqlserverflexCustomEndpoint") + def sqlserverflex_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the SQL Server Flex service + """ + return pulumi.get(self, "sqlserverflex_custom_endpoint") + + @property + @pulumi.getter(name="tokenCustomEndpoint") + def token_custom_endpoint(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Custom endpoint for the token API, which is used to request access tokens when using the key flow + """ + return pulumi.get(self, "token_custom_endpoint") + + @pulumi.output_type + class TerraformConfigResult: + def __init__(__self__, result=None): + if result and not isinstance(result, dict): + raise TypeError("Expected argument 'result' to be a dict") + pulumi.set(__self__, "result", result) + + @property + @pulumi.getter + def result(self) -> Mapping[str, Any]: + return pulumi.get(self, "result") + + def terraform_config(__self__) -> pulumi.Output['Provider.TerraformConfigResult']: + """ + This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. + """ + __args__ = dict() + __args__['__self__'] = __self__ + return pulumi.runtime.call('pulumi:providers:stackit/terraformConfig', __args__, res=__self__, typ=Provider.TerraformConfigResult) + diff --git a/sdk/python/pulumi_stackit/public_ip.py b/sdk/python/pulumi_stackit/public_ip.py new file mode 100644 index 0000000..43d6e2c --- /dev/null +++ b/sdk/python/pulumi_stackit/public_ip.py @@ -0,0 +1,294 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PublicIpArgs', 'PublicIp'] + +@pulumi.input_type +class PublicIpArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a PublicIp resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + """ + pulumi.set(__self__, "project_id", project_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if network_interface_id is not None: + pulumi.set(__self__, "network_interface_id", network_interface_id) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_interface_id", value) + + +@pulumi.input_type +class _PublicIpState: + def __init__(__self__, *, + ip: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering PublicIp resources. + :param pulumi.Input[builtins.str] ip: The IP address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + if ip is not None: + pulumi.set(__self__, "ip", ip) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if network_interface_id is not None: + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if public_ip_id is not None: + pulumi.set(__self__, "public_ip_id", public_ip_id) + + @property + @pulumi.getter + def ip(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IP address. + """ + return pulumi.get(self, "ip") + + @ip.setter + def ip(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ip", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + + @public_ip_id.setter + def public_ip_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_ip_id", value) + + +@pulumi.type_token("stackit:index/publicIp:PublicIp") +class PublicIp(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Public IP resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PublicIpArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Public IP resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param PublicIpArgs 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(PublicIpArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = PublicIpArgs.__new__(PublicIpArgs) + + __props__.__dict__["labels"] = labels + __props__.__dict__["network_interface_id"] = network_interface_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["ip"] = None + __props__.__dict__["public_ip_id"] = None + super(PublicIp, __self__).__init__( + 'stackit:index/publicIp:PublicIp', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + ip: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None) -> 'PublicIp': + """ + Get an existing PublicIp 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[builtins.str] ip: The IP address. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PublicIpState.__new__(_PublicIpState) + + __props__.__dict__["ip"] = ip + __props__.__dict__["labels"] = labels + __props__.__dict__["network_interface_id"] = network_interface_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["public_ip_id"] = public_ip_id + return PublicIp(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def ip(self) -> pulumi.Output[builtins.str]: + """ + The IP address. + """ + return pulumi.get(self, "ip") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> pulumi.Output[builtins.str]: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + diff --git a/sdk/python/pulumi_stackit/public_ip_associate.py b/sdk/python/pulumi_stackit/public_ip_associate.py new file mode 100644 index 0000000..c6f6629 --- /dev/null +++ b/sdk/python/pulumi_stackit/public_ip_associate.py @@ -0,0 +1,287 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['PublicIpAssociateArgs', 'PublicIpAssociate'] + +@pulumi.input_type +class PublicIpAssociateArgs: + def __init__(__self__, *, + network_interface_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + public_ip_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a PublicIpAssociate resource. + :param pulumi.Input[builtins.str] network_interface_id: The ID of the network interface (or virtual IP) to which the public IP should be attached to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + pulumi.set(__self__, "network_interface_id", network_interface_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "public_ip_id", public_ip_id) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Input[builtins.str]: + """ + The ID of the network interface (or virtual IP) to which the public IP should be attached to. + """ + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> pulumi.Input[builtins.str]: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + + @public_ip_id.setter + def public_ip_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "public_ip_id", value) + + +@pulumi.input_type +class _PublicIpAssociateState: + def __init__(__self__, *, + ip: Optional[pulumi.Input[builtins.str]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering PublicIpAssociate resources. + :param pulumi.Input[builtins.str] ip: The IP address. + :param pulumi.Input[builtins.str] network_interface_id: The ID of the network interface (or virtual IP) to which the public IP should be attached to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + if ip is not None: + pulumi.set(__self__, "ip", ip) + if network_interface_id is not None: + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if public_ip_id is not None: + pulumi.set(__self__, "public_ip_id", public_ip_id) + + @property + @pulumi.getter + def ip(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The IP address. + """ + return pulumi.get(self, "ip") + + @ip.setter + def ip(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ip", value) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ID of the network interface (or virtual IP) to which the public IP should be attached to. + """ + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + + @public_ip_id.setter + def public_ip_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_ip_id", value) + + +@pulumi.type_token("stackit:index/publicIpAssociate:PublicIpAssociate") +class PublicIpAssociate(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration. + + !> The `PublicIpAssociate` resource should not be used together with the `PublicIp` resource for the same public IP or for the same network interface. + Using both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] network_interface_id: The ID of the network interface (or virtual IP) to which the public IP should be attached to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PublicIpAssociateArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Associates an existing public IP to a network interface. This is useful for situations where you have a pre-allocated public IP or unable to use the `PublicIp` resource to create a new public IP. Must have a `region` specified in the provider configuration. + + !> The `PublicIpAssociate` resource should not be used together with the `PublicIp` resource for the same public IP or for the same network interface. + Using both resources together for the same public IP or network interface WILL lead to conflicts, as they both have control of the public IP and network interface association. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param PublicIpAssociateArgs 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(PublicIpAssociateArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.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__ = PublicIpAssociateArgs.__new__(PublicIpAssociateArgs) + + if network_interface_id is None and not opts.urn: + raise TypeError("Missing required property 'network_interface_id'") + __props__.__dict__["network_interface_id"] = network_interface_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if public_ip_id is None and not opts.urn: + raise TypeError("Missing required property 'public_ip_id'") + __props__.__dict__["public_ip_id"] = public_ip_id + __props__.__dict__["ip"] = None + super(PublicIpAssociate, __self__).__init__( + 'stackit:index/publicIpAssociate:PublicIpAssociate', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + ip: Optional[pulumi.Input[builtins.str]] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_ip_id: Optional[pulumi.Input[builtins.str]] = None) -> 'PublicIpAssociate': + """ + Get an existing PublicIpAssociate 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[builtins.str] ip: The IP address. + :param pulumi.Input[builtins.str] network_interface_id: The ID of the network interface (or virtual IP) to which the public IP should be attached to. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the public IP is associated. + :param pulumi.Input[builtins.str] public_ip_id: The public IP ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PublicIpAssociateState.__new__(_PublicIpAssociateState) + + __props__.__dict__["ip"] = ip + __props__.__dict__["network_interface_id"] = network_interface_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["public_ip_id"] = public_ip_id + return PublicIpAssociate(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def ip(self) -> pulumi.Output[builtins.str]: + """ + The IP address. + """ + return pulumi.get(self, "ip") + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Output[builtins.str]: + """ + The ID of the network interface (or virtual IP) to which the public IP should be attached to. + """ + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the public IP is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicIpId") + def public_ip_id(self) -> pulumi.Output[builtins.str]: + """ + The public IP ID. + """ + return pulumi.get(self, "public_ip_id") + diff --git a/sdk/python/pulumi_stackit/pulumi-plugin.json b/sdk/python/pulumi_stackit/pulumi-plugin.json new file mode 100644 index 0000000..60d9f21 --- /dev/null +++ b/sdk/python/pulumi_stackit/pulumi-plugin.json @@ -0,0 +1,5 @@ +{ + "resource": true, + "name": "stackit", + "server": "github://api.github.com/stackitcloud/pulumi-stackit" +} diff --git a/sdk/python/pulumi_stackit/py.typed b/sdk/python/pulumi_stackit/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/sdk/python/pulumi_stackit/rabbitmq_credential.py b/sdk/python/pulumi_stackit/rabbitmq_credential.py new file mode 100644 index 0000000..6160517 --- /dev/null +++ b/sdk/python/pulumi_stackit/rabbitmq_credential.py @@ -0,0 +1,435 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['RabbitmqCredentialArgs', 'RabbitmqCredential'] + +@pulumi.input_type +class RabbitmqCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a RabbitmqCredential resource. + :param pulumi.Input[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _RabbitmqCredentialState: + def __init__(__self__, *, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + http_api_uri: Optional[pulumi.Input[builtins.str]] = None, + http_api_uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + management: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering RabbitmqCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if host is not None: + pulumi.set(__self__, "host", host) + if hosts is not None: + pulumi.set(__self__, "hosts", hosts) + if http_api_uri is not None: + pulumi.set(__self__, "http_api_uri", http_api_uri) + if http_api_uris is not None: + pulumi.set(__self__, "http_api_uris", http_api_uris) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if management is not None: + pulumi.set(__self__, "management", management) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if uris is not None: + pulumi.set(__self__, "uris", uris) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter + def hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "hosts") + + @hosts.setter + def hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "hosts", value) + + @property + @pulumi.getter(name="httpApiUri") + def http_api_uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "http_api_uri") + + @http_api_uri.setter + def http_api_uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "http_api_uri", value) + + @property + @pulumi.getter(name="httpApiUris") + def http_api_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "http_api_uris") + + @http_api_uris.setter + def http_api_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "http_api_uris", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def management(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "management") + + @management.setter + def management(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "management", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter + def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "uris") + + @uris.setter + def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "uris", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/rabbitmqCredential:RabbitmqCredential") +class RabbitmqCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RabbitmqCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + RabbitMQ credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param RabbitmqCredentialArgs 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(RabbitmqCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = RabbitmqCredentialArgs.__new__(RabbitmqCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["credential_id"] = None + __props__.__dict__["host"] = None + __props__.__dict__["hosts"] = None + __props__.__dict__["http_api_uri"] = None + __props__.__dict__["http_api_uris"] = None + __props__.__dict__["management"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["uris"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(RabbitmqCredential, __self__).__init__( + 'stackit:index/rabbitmqCredential:RabbitmqCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + http_api_uri: Optional[pulumi.Input[builtins.str]] = None, + http_api_uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + management: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + uris: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'RabbitmqCredential': + """ + Get an existing RabbitmqCredential 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[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RabbitmqCredentialState.__new__(_RabbitmqCredentialState) + + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["host"] = host + __props__.__dict__["hosts"] = hosts + __props__.__dict__["http_api_uri"] = http_api_uri + __props__.__dict__["http_api_uris"] = http_api_uris + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["management"] = management + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["uri"] = uri + __props__.__dict__["uris"] = uris + __props__.__dict__["username"] = username + return RabbitmqCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter(name="httpApiUri") + def http_api_uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "http_api_uri") + + @property + @pulumi.getter(name="httpApiUris") + def http_api_uris(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "http_api_uris") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def management(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "management") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def uris(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "uris") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/rabbitmq_instance.py b/sdk/python/pulumi_stackit/rabbitmq_instance.py new file mode 100644 index 0000000..122638d --- /dev/null +++ b/sdk/python/pulumi_stackit/rabbitmq_instance.py @@ -0,0 +1,492 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['RabbitmqInstanceArgs', 'RabbitmqInstance'] + +@pulumi.input_type +class RabbitmqInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['RabbitmqInstanceParametersArgs']] = None): + """ + The set of arguments for constructing a RabbitmqInstance resource. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['RabbitmqInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['RabbitmqInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _RabbitmqInstanceState: + def __init__(__self__, *, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['RabbitmqInstanceParametersArgs']] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering RabbitmqInstance resources. + :param pulumi.Input[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + if cf_guid is not None: + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid is not None: + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid is not None: + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_guid") + + @cf_guid.setter + def cf_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_guid", value) + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_organization_guid") + + @cf_organization_guid.setter + def cf_organization_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_organization_guid", value) + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_space_guid") + + @cf_space_guid.setter + def cf_space_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_space_guid", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['RabbitmqInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['RabbitmqInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/rabbitmqInstance:RabbitmqInstance") +class RabbitmqInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RabbitmqInstanceParametersArgs', 'RabbitmqInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RabbitmqInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + RabbitMQ instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param RabbitmqInstanceArgs 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(RabbitmqInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RabbitmqInstanceParametersArgs', 'RabbitmqInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.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__ = RabbitmqInstanceArgs.__new__(RabbitmqInstanceArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["cf_guid"] = None + __props__.__dict__["cf_organization_guid"] = None + __props__.__dict__["cf_space_guid"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["image_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["plan_id"] = None + super(RabbitmqInstance, __self__).__init__( + 'stackit:index/rabbitmqInstance:RabbitmqInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RabbitmqInstanceParametersArgs', 'RabbitmqInstanceParametersArgsDict']]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'RabbitmqInstance': + """ + Get an existing RabbitmqInstance 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[builtins.str] instance_id: ID of the RabbitMQ instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RabbitmqInstanceState.__new__(_RabbitmqInstanceState) + + __props__.__dict__["cf_guid"] = cf_guid + __props__.__dict__["cf_organization_guid"] = cf_organization_guid + __props__.__dict__["cf_space_guid"] = cf_space_guid + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["version"] = version + return RabbitmqInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the RabbitMQ instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output['outputs.RabbitmqInstanceParameters']: + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/redis_credential.py b/sdk/python/pulumi_stackit/redis_credential.py new file mode 100644 index 0000000..8817f22 --- /dev/null +++ b/sdk/python/pulumi_stackit/redis_credential.py @@ -0,0 +1,383 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['RedisCredentialArgs', 'RedisCredential'] + +@pulumi.input_type +class RedisCredentialArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a RedisCredential resource. + :param pulumi.Input[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + +@pulumi.input_type +class _RedisCredentialState: + def __init__(__self__, *, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + load_balanced_host: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering RedisCredential resources. + :param pulumi.Input[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.str] uri: Connection URI. + """ + if credential_id is not None: + pulumi.set(__self__, "credential_id", credential_id) + if host is not None: + pulumi.set(__self__, "host", host) + if hosts is not None: + pulumi.set(__self__, "hosts", hosts) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if load_balanced_host is not None: + pulumi.set(__self__, "load_balanced_host", load_balanced_host) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if uri is not None: + pulumi.set(__self__, "uri", uri) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @credential_id.setter + def credential_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "credential_id", value) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter + def hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + return pulumi.get(self, "hosts") + + @hosts.setter + def hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "hosts", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="loadBalancedHost") + def load_balanced_host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "load_balanced_host") + + @load_balanced_host.setter + def load_balanced_host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "load_balanced_host", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def uri(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Connection URI. + """ + return pulumi.get(self, "uri") + + @uri.setter + def uri(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "uri", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/redisCredential:RedisCredential") +class RedisCredential(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Redis credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RedisCredentialArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Redis credential resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param RedisCredentialArgs 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(RedisCredentialArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = RedisCredentialArgs.__new__(RedisCredentialArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["credential_id"] = None + __props__.__dict__["host"] = None + __props__.__dict__["hosts"] = None + __props__.__dict__["load_balanced_host"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["uri"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password", "uri"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(RedisCredential, __self__).__init__( + 'stackit:index/redisCredential:RedisCredential', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + credential_id: Optional[pulumi.Input[builtins.str]] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + load_balanced_host: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + uri: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'RedisCredential': + """ + Get an existing RedisCredential 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[builtins.str] credential_id: The credential's ID. + :param pulumi.Input[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.str] uri: Connection URI. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RedisCredentialState.__new__(_RedisCredentialState) + + __props__.__dict__["credential_id"] = credential_id + __props__.__dict__["host"] = host + __props__.__dict__["hosts"] = hosts + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["load_balanced_host"] = load_balanced_host + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["uri"] = uri + __props__.__dict__["username"] = username + return RedisCredential(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="credentialId") + def credential_id(self) -> pulumi.Output[builtins.str]: + """ + The credential's ID. + """ + return pulumi.get(self, "credential_id") + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter + def hosts(self) -> pulumi.Output[Sequence[builtins.str]]: + return pulumi.get(self, "hosts") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter(name="loadBalancedHost") + def load_balanced_host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "load_balanced_host") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def uri(self) -> pulumi.Output[builtins.str]: + """ + Connection URI. + """ + return pulumi.get(self, "uri") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/redis_instance.py b/sdk/python/pulumi_stackit/redis_instance.py new file mode 100644 index 0000000..914bfd1 --- /dev/null +++ b/sdk/python/pulumi_stackit/redis_instance.py @@ -0,0 +1,492 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['RedisInstanceArgs', 'RedisInstance'] + +@pulumi.input_type +class RedisInstanceArgs: + def __init__(__self__, *, + plan_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + version: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['RedisInstanceParametersArgs']] = None): + """ + The set of arguments for constructing a RedisInstance resource. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "plan_name", plan_name) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "version", version) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Input[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> pulumi.Input[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "version", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['RedisInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['RedisInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + +@pulumi.input_type +class _RedisInstanceState: + def __init__(__self__, *, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input['RedisInstanceParametersArgs']] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering RedisInstance resources. + :param pulumi.Input[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + if cf_guid is not None: + pulumi.set(__self__, "cf_guid", cf_guid) + if cf_organization_guid is not None: + pulumi.set(__self__, "cf_organization_guid", cf_organization_guid) + if cf_space_guid is not None: + pulumi.set(__self__, "cf_space_guid", cf_space_guid) + if dashboard_url is not None: + pulumi.set(__self__, "dashboard_url", dashboard_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if parameters is not None: + pulumi.set(__self__, "parameters", parameters) + if plan_id is not None: + pulumi.set(__self__, "plan_id", plan_id) + if plan_name is not None: + pulumi.set(__self__, "plan_name", plan_name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_guid") + + @cf_guid.setter + def cf_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_guid", value) + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_organization_guid") + + @cf_organization_guid.setter + def cf_organization_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_organization_guid", value) + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "cf_space_guid") + + @cf_space_guid.setter + def cf_space_guid(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cf_space_guid", value) + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "dashboard_url") + + @dashboard_url.setter + def dashboard_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "dashboard_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def parameters(self) -> Optional[pulumi.Input['RedisInstanceParametersArgs']]: + return pulumi.get(self, "parameters") + + @parameters.setter + def parameters(self, value: Optional[pulumi.Input['RedisInstanceParametersArgs']]): + pulumi.set(self, "parameters", value) + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @plan_id.setter + def plan_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_id", value) + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @plan_name.setter + def plan_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "plan_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service version. + """ + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/redisInstance:RedisInstance") +class RedisInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RedisInstanceParametersArgs', 'RedisInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Redis instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RedisInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Redis instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param RedisInstanceArgs 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(RedisInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RedisInstanceParametersArgs', 'RedisInstanceParametersArgsDict']]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.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__ = RedisInstanceArgs.__new__(RedisInstanceArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + if plan_name is None and not opts.urn: + raise TypeError("Missing required property 'plan_name'") + __props__.__dict__["plan_name"] = plan_name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if version is None and not opts.urn: + raise TypeError("Missing required property 'version'") + __props__.__dict__["version"] = version + __props__.__dict__["cf_guid"] = None + __props__.__dict__["cf_organization_guid"] = None + __props__.__dict__["cf_space_guid"] = None + __props__.__dict__["dashboard_url"] = None + __props__.__dict__["image_url"] = None + __props__.__dict__["instance_id"] = None + __props__.__dict__["plan_id"] = None + super(RedisInstance, __self__).__init__( + 'stackit:index/redisInstance:RedisInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cf_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_organization_guid: Optional[pulumi.Input[builtins.str]] = None, + cf_space_guid: Optional[pulumi.Input[builtins.str]] = None, + dashboard_url: Optional[pulumi.Input[builtins.str]] = None, + image_url: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + parameters: Optional[pulumi.Input[Union['RedisInstanceParametersArgs', 'RedisInstanceParametersArgsDict']]] = None, + plan_id: Optional[pulumi.Input[builtins.str]] = None, + plan_name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'RedisInstance': + """ + Get an existing RedisInstance 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[builtins.str] instance_id: ID of the Redis instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] plan_id: The selected plan ID. + :param pulumi.Input[builtins.str] plan_name: The selected plan name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] version: The service version. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RedisInstanceState.__new__(_RedisInstanceState) + + __props__.__dict__["cf_guid"] = cf_guid + __props__.__dict__["cf_organization_guid"] = cf_organization_guid + __props__.__dict__["cf_space_guid"] = cf_space_guid + __props__.__dict__["dashboard_url"] = dashboard_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["parameters"] = parameters + __props__.__dict__["plan_id"] = plan_id + __props__.__dict__["plan_name"] = plan_name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["version"] = version + return RedisInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="cfGuid") + def cf_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_guid") + + @property + @pulumi.getter(name="cfOrganizationGuid") + def cf_organization_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_organization_guid") + + @property + @pulumi.getter(name="cfSpaceGuid") + def cf_space_guid(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "cf_space_guid") + + @property + @pulumi.getter(name="dashboardUrl") + def dashboard_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "dashboard_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the Redis instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def parameters(self) -> pulumi.Output['outputs.RedisInstanceParameters']: + return pulumi.get(self, "parameters") + + @property + @pulumi.getter(name="planId") + def plan_id(self) -> pulumi.Output[builtins.str]: + """ + The selected plan ID. + """ + return pulumi.get(self, "plan_id") + + @property + @pulumi.getter(name="planName") + def plan_name(self) -> pulumi.Output[builtins.str]: + """ + The selected plan name. + """ + return pulumi.get(self, "plan_name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + """ + The service version. + """ + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/resourcemanager_project.py b/sdk/python/pulumi_stackit/resourcemanager_project.py new file mode 100644 index 0000000..ccd2e2e --- /dev/null +++ b/sdk/python/pulumi_stackit/resourcemanager_project.py @@ -0,0 +1,351 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ResourcemanagerProjectArgs', 'ResourcemanagerProject'] + +@pulumi.input_type +class ResourcemanagerProjectArgs: + def __init__(__self__, *, + owner_email: pulumi.Input[builtins.str], + parent_container_id: pulumi.Input[builtins.str], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ResourcemanagerProject resource. + :param pulumi.Input[builtins.str] owner_email: Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + :param pulumi.Input[builtins.str] parent_container_id: Parent resource identifier. Both container ID (user-friendly) and UUID are supported + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + :param pulumi.Input[builtins.str] name: Project name. + """ + pulumi.set(__self__, "owner_email", owner_email) + pulumi.set(__self__, "parent_container_id", parent_container_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="ownerEmail") + def owner_email(self) -> pulumi.Input[builtins.str]: + """ + Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + """ + return pulumi.get(self, "owner_email") + + @owner_email.setter + def owner_email(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "owner_email", value) + + @property + @pulumi.getter(name="parentContainerId") + def parent_container_id(self) -> pulumi.Input[builtins.str]: + """ + Parent resource identifier. Both container ID (user-friendly) and UUID are supported + """ + return pulumi.get(self, "parent_container_id") + + @parent_container_id.setter + def parent_container_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "parent_container_id", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Project name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ResourcemanagerProjectState: + def __init__(__self__, *, + container_id: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner_email: Optional[pulumi.Input[builtins.str]] = None, + parent_container_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ResourcemanagerProject resources. + :param pulumi.Input[builtins.str] container_id: Project container ID. Globally unique, user-friendly identifier. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + :param pulumi.Input[builtins.str] name: Project name. + :param pulumi.Input[builtins.str] owner_email: Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + :param pulumi.Input[builtins.str] parent_container_id: Parent resource identifier. Both container ID (user-friendly) and UUID are supported + :param pulumi.Input[builtins.str] project_id: Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + if container_id is not None: + pulumi.set(__self__, "container_id", container_id) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if owner_email is not None: + pulumi.set(__self__, "owner_email", owner_email) + if parent_container_id is not None: + pulumi.set(__self__, "parent_container_id", parent_container_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter(name="containerId") + def container_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Project container ID. Globally unique, user-friendly identifier. + """ + return pulumi.get(self, "container_id") + + @container_id.setter + def container_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "container_id", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Project name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="ownerEmail") + def owner_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + """ + return pulumi.get(self, "owner_email") + + @owner_email.setter + def owner_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "owner_email", value) + + @property + @pulumi.getter(name="parentContainerId") + def parent_container_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Parent resource identifier. Both container ID (user-friendly) and UUID are supported + """ + return pulumi.get(self, "parent_container_id") + + @parent_container_id.setter + def parent_container_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "parent_container_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + +@pulumi.type_token("stackit:index/resourcemanagerProject:ResourcemanagerProject") +class ResourcemanagerProject(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner_email: Optional[pulumi.Input[builtins.str]] = None, + parent_container_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + :param pulumi.Input[builtins.str] name: Project name. + :param pulumi.Input[builtins.str] owner_email: Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + :param pulumi.Input[builtins.str] parent_container_id: Parent resource identifier. Both container ID (user-friendly) and UUID are supported + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ResourcemanagerProjectArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ## Example Usage + + :param str resource_name: The name of the resource. + :param ResourcemanagerProjectArgs 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(ResourcemanagerProjectArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner_email: Optional[pulumi.Input[builtins.str]] = None, + parent_container_id: Optional[pulumi.Input[builtins.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__ = ResourcemanagerProjectArgs.__new__(ResourcemanagerProjectArgs) + + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + if owner_email is None and not opts.urn: + raise TypeError("Missing required property 'owner_email'") + __props__.__dict__["owner_email"] = owner_email + if parent_container_id is None and not opts.urn: + raise TypeError("Missing required property 'parent_container_id'") + __props__.__dict__["parent_container_id"] = parent_container_id + __props__.__dict__["container_id"] = None + __props__.__dict__["project_id"] = None + super(ResourcemanagerProject, __self__).__init__( + 'stackit:index/resourcemanagerProject:ResourcemanagerProject', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + container_id: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + owner_email: Optional[pulumi.Input[builtins.str]] = None, + parent_container_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ResourcemanagerProject': + """ + Get an existing ResourcemanagerProject 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[builtins.str] container_id: Project container ID. Globally unique, user-friendly identifier. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + :param pulumi.Input[builtins.str] name: Project name. + :param pulumi.Input[builtins.str] owner_email: Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + :param pulumi.Input[builtins.str] parent_container_id: Parent resource identifier. Both container ID (user-friendly) and UUID are supported + :param pulumi.Input[builtins.str] project_id: Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ResourcemanagerProjectState.__new__(_ResourcemanagerProjectState) + + __props__.__dict__["container_id"] = container_id + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["owner_email"] = owner_email + __props__.__dict__["parent_container_id"] = parent_container_id + __props__.__dict__["project_id"] = project_id + return ResourcemanagerProject(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="containerId") + def container_id(self) -> pulumi.Output[builtins.str]: + """ + Project container ID. Globally unique, user-friendly identifier. + """ + return pulumi.get(self, "container_id") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container. A label key must match the regex [A-ZÄÜÖa-zäüöß0-9*-]{1,64}. A label value must match the regex ^$|[A-ZÄÜÖa-zäüöß0-9*-]{1,64}. To add a project to a STACKIT Network Area, setting the label `networkArea=` is required. + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Project name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="ownerEmail") + def owner_email(self) -> pulumi.Output[builtins.str]: + """ + Email address of the owner of the project. This value is only considered during creation. Changing it afterwards will have no effect. + """ + return pulumi.get(self, "owner_email") + + @property + @pulumi.getter(name="parentContainerId") + def parent_container_id(self) -> pulumi.Output[builtins.str]: + """ + Parent resource identifier. Both container ID (user-friendly) and UUID are supported + """ + return pulumi.get(self, "parent_container_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + Project UUID identifier. This is the ID that can be used in most of the other resources to identify the project. + """ + return pulumi.get(self, "project_id") + diff --git a/sdk/python/pulumi_stackit/secretsmanager_instance.py b/sdk/python/pulumi_stackit/secretsmanager_instance.py new file mode 100644 index 0000000..1dca996 --- /dev/null +++ b/sdk/python/pulumi_stackit/secretsmanager_instance.py @@ -0,0 +1,279 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['SecretsmanagerInstanceArgs', 'SecretsmanagerInstance'] + +@pulumi.input_type +class SecretsmanagerInstanceArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a SecretsmanagerInstance resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + :param pulumi.Input[builtins.str] name: Instance name. + """ + pulumi.set(__self__, "project_id", project_id) + if acls is not None: + pulumi.set(__self__, "acls", acls) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _SecretsmanagerInstanceState: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering SecretsmanagerInstance resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + +@pulumi.type_token("stackit:index/secretsmanagerInstance:SecretsmanagerInstance") +class SecretsmanagerInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SecretsmanagerInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Secrets Manager instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SecretsmanagerInstanceArgs 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(SecretsmanagerInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = SecretsmanagerInstanceArgs.__new__(SecretsmanagerInstanceArgs) + + __props__.__dict__["acls"] = acls + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["instance_id"] = None + super(SecretsmanagerInstance, __self__).__init__( + 'stackit:index/secretsmanagerInstance:SecretsmanagerInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None) -> 'SecretsmanagerInstance': + """ + Get an existing SecretsmanagerInstance 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[Sequence[pulumi.Input[builtins.str]]] acls: The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SecretsmanagerInstanceState.__new__(_SecretsmanagerInstanceState) + + __props__.__dict__["acls"] = acls + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + return SecretsmanagerInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acls(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]: + """ + The access control list for this instance. Each entry is an IP or IP range that is permitted to access, in CIDR notation + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + diff --git a/sdk/python/pulumi_stackit/secretsmanager_user.py b/sdk/python/pulumi_stackit/secretsmanager_user.py new file mode 100644 index 0000000..63ea4aa --- /dev/null +++ b/sdk/python/pulumi_stackit/secretsmanager_user.py @@ -0,0 +1,387 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['SecretsmanagerUserArgs', 'SecretsmanagerUser'] + +@pulumi.input_type +class SecretsmanagerUserArgs: + def __init__(__self__, *, + description: pulumi.Input[builtins.str], + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + write_enabled: pulumi.Input[builtins.bool]): + """ + The set of arguments for constructing a SecretsmanagerUser resource. + :param pulumi.Input[builtins.str] description: A user chosen description to differentiate between multiple users. Can't be changed after creation. + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.bool] write_enabled: If true, the user has writeaccess to the secrets engine. + """ + pulumi.set(__self__, "description", description) + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "write_enabled", write_enabled) + + @property + @pulumi.getter + def description(self) -> pulumi.Input[builtins.str]: + """ + A user chosen description to differentiate between multiple users. Can't be changed after creation. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="writeEnabled") + def write_enabled(self) -> pulumi.Input[builtins.bool]: + """ + If true, the user has writeaccess to the secrets engine. + """ + return pulumi.get(self, "write_enabled") + + @write_enabled.setter + def write_enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "write_enabled", value) + + +@pulumi.input_type +class _SecretsmanagerUserState: + def __init__(__self__, *, + description: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + write_enabled: Optional[pulumi.Input[builtins.bool]] = None): + """ + Input properties used for looking up and filtering SecretsmanagerUser resources. + :param pulumi.Input[builtins.str] description: A user chosen description to differentiate between multiple users. Can't be changed after creation. + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] password: An auto-generated password. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.str] user_id: The user's ID. + :param pulumi.Input[builtins.str] username: An auto-generated user name. + :param pulumi.Input[builtins.bool] write_enabled: If true, the user has writeaccess to the secrets engine. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if username is not None: + pulumi.set(__self__, "username", username) + if write_enabled is not None: + pulumi.set(__self__, "write_enabled", write_enabled) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + A user chosen description to differentiate between multiple users. Can't be changed after creation. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + An auto-generated password. + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The user's ID. + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_id", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + An auto-generated user name. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + @property + @pulumi.getter(name="writeEnabled") + def write_enabled(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If true, the user has writeaccess to the secrets engine. + """ + return pulumi.get(self, "write_enabled") + + @write_enabled.setter + def write_enabled(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "write_enabled", value) + + +@pulumi.type_token("stackit:index/secretsmanagerUser:SecretsmanagerUser") +class SecretsmanagerUser(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + write_enabled: Optional[pulumi.Input[builtins.bool]] = None, + __props__=None): + """ + Secrets Manager user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] description: A user chosen description to differentiate between multiple users. Can't be changed after creation. + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.bool] write_enabled: If true, the user has writeaccess to the secrets engine. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SecretsmanagerUserArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Secrets Manager user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SecretsmanagerUserArgs 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(SecretsmanagerUserArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + write_enabled: Optional[pulumi.Input[builtins.bool]] = 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__ = SecretsmanagerUserArgs.__new__(SecretsmanagerUserArgs) + + if description is None and not opts.urn: + raise TypeError("Missing required property 'description'") + __props__.__dict__["description"] = description + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if write_enabled is None and not opts.urn: + raise TypeError("Missing required property 'write_enabled'") + __props__.__dict__["write_enabled"] = write_enabled + __props__.__dict__["password"] = None + __props__.__dict__["user_id"] = None + __props__.__dict__["username"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(SecretsmanagerUser, __self__).__init__( + 'stackit:index/secretsmanagerUser:SecretsmanagerUser', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + write_enabled: Optional[pulumi.Input[builtins.bool]] = None) -> 'SecretsmanagerUser': + """ + Get an existing SecretsmanagerUser 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[builtins.str] description: A user chosen description to differentiate between multiple users. Can't be changed after creation. + :param pulumi.Input[builtins.str] instance_id: ID of the Secrets Manager instance. + :param pulumi.Input[builtins.str] password: An auto-generated password. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the instance is associated. + :param pulumi.Input[builtins.str] user_id: The user's ID. + :param pulumi.Input[builtins.str] username: An auto-generated user name. + :param pulumi.Input[builtins.bool] write_enabled: If true, the user has writeaccess to the secrets engine. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SecretsmanagerUserState.__new__(_SecretsmanagerUserState) + + __props__.__dict__["description"] = description + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["project_id"] = project_id + __props__.__dict__["user_id"] = user_id + __props__.__dict__["username"] = username + __props__.__dict__["write_enabled"] = write_enabled + return SecretsmanagerUser(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[builtins.str]: + """ + A user chosen description to differentiate between multiple users. Can't be changed after creation. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the Secrets Manager instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + """ + An auto-generated password. + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[builtins.str]: + """ + The user's ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + """ + An auto-generated user name. + """ + return pulumi.get(self, "username") + + @property + @pulumi.getter(name="writeEnabled") + def write_enabled(self) -> pulumi.Output[builtins.bool]: + """ + If true, the user has writeaccess to the secrets engine. + """ + return pulumi.get(self, "write_enabled") + diff --git a/sdk/python/pulumi_stackit/security_group.py b/sdk/python/pulumi_stackit/security_group.py new file mode 100644 index 0000000..0f595b1 --- /dev/null +++ b/sdk/python/pulumi_stackit/security_group.py @@ -0,0 +1,373 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['SecurityGroupArgs', 'SecurityGroup'] + +@pulumi.input_type +class SecurityGroupArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + stateful: Optional[pulumi.Input[builtins.bool]] = None): + """ + The set of arguments for constructing a SecurityGroup resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group is associated. + :param pulumi.Input[builtins.str] description: The description of the security group. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the security group. + :param pulumi.Input[builtins.bool] stateful: Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + pulumi.set(__self__, "project_id", project_id) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if stateful is not None: + pulumi.set(__self__, "stateful", stateful) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the security group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the security group. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the security group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def stateful(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + return pulumi.get(self, "stateful") + + @stateful.setter + def stateful(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "stateful", value) + + +@pulumi.input_type +class _SecurityGroupState: + def __init__(__self__, *, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + stateful: Optional[pulumi.Input[builtins.bool]] = None): + """ + Input properties used for looking up and filtering SecurityGroup resources. + :param pulumi.Input[builtins.str] description: The description of the security group. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the security group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group is associated. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + :param pulumi.Input[builtins.bool] stateful: Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if security_group_id is not None: + pulumi.set(__self__, "security_group_id", security_group_id) + if stateful is not None: + pulumi.set(__self__, "stateful", stateful) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the security group. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the security group. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the security group is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @security_group_id.setter + def security_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "security_group_id", value) + + @property + @pulumi.getter + def stateful(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + return pulumi.get(self, "stateful") + + @stateful.setter + def stateful(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "stateful", value) + + +@pulumi.type_token("stackit:index/securityGroup:SecurityGroup") +class SecurityGroup(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + stateful: Optional[pulumi.Input[builtins.bool]] = None, + __props__=None): + """ + Security group resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] description: The description of the security group. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the security group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group is associated. + :param pulumi.Input[builtins.bool] stateful: Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SecurityGroupArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Security group resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SecurityGroupArgs 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(SecurityGroupArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + stateful: Optional[pulumi.Input[builtins.bool]] = 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__ = SecurityGroupArgs.__new__(SecurityGroupArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["stateful"] = stateful + __props__.__dict__["security_group_id"] = None + super(SecurityGroup, __self__).__init__( + 'stackit:index/securityGroup:SecurityGroup', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + stateful: Optional[pulumi.Input[builtins.bool]] = None) -> 'SecurityGroup': + """ + Get an existing SecurityGroup 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[builtins.str] description: The description of the security group. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the security group. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group is associated. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + :param pulumi.Input[builtins.bool] stateful: Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SecurityGroupState.__new__(_SecurityGroupState) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["security_group_id"] = security_group_id + __props__.__dict__["stateful"] = stateful + return SecurityGroup(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[builtins.str]: + """ + The description of the security group. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the security group. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the security group is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> pulumi.Output[builtins.str]: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @property + @pulumi.getter + def stateful(self) -> pulumi.Output[builtins.bool]: + """ + Configures if a security group is stateful or stateless. There can only be one type of security groups per network interface/server. + """ + return pulumi.get(self, "stateful") + diff --git a/sdk/python/pulumi_stackit/security_group_rule.py b/sdk/python/pulumi_stackit/security_group_rule.py new file mode 100644 index 0000000..4b29583 --- /dev/null +++ b/sdk/python/pulumi_stackit/security_group_rule.py @@ -0,0 +1,612 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['SecurityGroupRuleArgs', 'SecurityGroupRule'] + +@pulumi.input_type +class SecurityGroupRuleArgs: + def __init__(__self__, *, + direction: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + security_group_id: pulumi.Input[builtins.str], + description: Optional[pulumi.Input[builtins.str]] = None, + ether_type: Optional[pulumi.Input[builtins.str]] = None, + icmp_parameters: Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']] = None, + ip_range: Optional[pulumi.Input[builtins.str]] = None, + port_range: Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']] = None, + protocol: Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']] = None, + remote_security_group_id: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a SecurityGroupRule resource. + :param pulumi.Input[builtins.str] direction: The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group rule is associated. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + :param pulumi.Input[builtins.str] description: The rule description. + :param pulumi.Input[builtins.str] ether_type: The ethertype which the rule should match. + :param pulumi.Input['SecurityGroupRuleIcmpParametersArgs'] icmp_parameters: ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + :param pulumi.Input[builtins.str] ip_range: The remote IP range which the rule should match. + :param pulumi.Input['SecurityGroupRulePortRangeArgs'] port_range: The range of ports. This should only be provided if the protocol is not ICMP. + :param pulumi.Input['SecurityGroupRuleProtocolArgs'] protocol: The internet protocol which the rule should match. + :param pulumi.Input[builtins.str] remote_security_group_id: The remote security group which the rule should match. + """ + pulumi.set(__self__, "direction", direction) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "security_group_id", security_group_id) + if description is not None: + pulumi.set(__self__, "description", description) + if ether_type is not None: + pulumi.set(__self__, "ether_type", ether_type) + if icmp_parameters is not None: + pulumi.set(__self__, "icmp_parameters", icmp_parameters) + if ip_range is not None: + pulumi.set(__self__, "ip_range", ip_range) + if port_range is not None: + pulumi.set(__self__, "port_range", port_range) + if protocol is not None: + pulumi.set(__self__, "protocol", protocol) + if remote_security_group_id is not None: + pulumi.set(__self__, "remote_security_group_id", remote_security_group_id) + + @property + @pulumi.getter + def direction(self) -> pulumi.Input[builtins.str]: + """ + The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + """ + return pulumi.get(self, "direction") + + @direction.setter + def direction(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "direction", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the security group rule is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> pulumi.Input[builtins.str]: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @security_group_id.setter + def security_group_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "security_group_id", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The rule description. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="etherType") + def ether_type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ethertype which the rule should match. + """ + return pulumi.get(self, "ether_type") + + @ether_type.setter + def ether_type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ether_type", value) + + @property + @pulumi.getter(name="icmpParameters") + def icmp_parameters(self) -> Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']]: + """ + ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + """ + return pulumi.get(self, "icmp_parameters") + + @icmp_parameters.setter + def icmp_parameters(self, value: Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']]): + pulumi.set(self, "icmp_parameters", value) + + @property + @pulumi.getter(name="ipRange") + def ip_range(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The remote IP range which the rule should match. + """ + return pulumi.get(self, "ip_range") + + @ip_range.setter + def ip_range(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ip_range", value) + + @property + @pulumi.getter(name="portRange") + def port_range(self) -> Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']]: + """ + The range of ports. This should only be provided if the protocol is not ICMP. + """ + return pulumi.get(self, "port_range") + + @port_range.setter + def port_range(self, value: Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']]): + pulumi.set(self, "port_range", value) + + @property + @pulumi.getter + def protocol(self) -> Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']]: + """ + The internet protocol which the rule should match. + """ + return pulumi.get(self, "protocol") + + @protocol.setter + def protocol(self, value: Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']]): + pulumi.set(self, "protocol", value) + + @property + @pulumi.getter(name="remoteSecurityGroupId") + def remote_security_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The remote security group which the rule should match. + """ + return pulumi.get(self, "remote_security_group_id") + + @remote_security_group_id.setter + def remote_security_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "remote_security_group_id", value) + + +@pulumi.input_type +class _SecurityGroupRuleState: + def __init__(__self__, *, + description: Optional[pulumi.Input[builtins.str]] = None, + direction: Optional[pulumi.Input[builtins.str]] = None, + ether_type: Optional[pulumi.Input[builtins.str]] = None, + icmp_parameters: Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']] = None, + ip_range: Optional[pulumi.Input[builtins.str]] = None, + port_range: Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protocol: Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']] = None, + remote_security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_rule_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering SecurityGroupRule resources. + :param pulumi.Input[builtins.str] description: The rule description. + :param pulumi.Input[builtins.str] direction: The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + :param pulumi.Input[builtins.str] ether_type: The ethertype which the rule should match. + :param pulumi.Input['SecurityGroupRuleIcmpParametersArgs'] icmp_parameters: ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + :param pulumi.Input[builtins.str] ip_range: The remote IP range which the rule should match. + :param pulumi.Input['SecurityGroupRulePortRangeArgs'] port_range: The range of ports. This should only be provided if the protocol is not ICMP. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group rule is associated. + :param pulumi.Input['SecurityGroupRuleProtocolArgs'] protocol: The internet protocol which the rule should match. + :param pulumi.Input[builtins.str] remote_security_group_id: The remote security group which the rule should match. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + :param pulumi.Input[builtins.str] security_group_rule_id: The security group rule ID. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if direction is not None: + pulumi.set(__self__, "direction", direction) + if ether_type is not None: + pulumi.set(__self__, "ether_type", ether_type) + if icmp_parameters is not None: + pulumi.set(__self__, "icmp_parameters", icmp_parameters) + if ip_range is not None: + pulumi.set(__self__, "ip_range", ip_range) + if port_range is not None: + pulumi.set(__self__, "port_range", port_range) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if protocol is not None: + pulumi.set(__self__, "protocol", protocol) + if remote_security_group_id is not None: + pulumi.set(__self__, "remote_security_group_id", remote_security_group_id) + if security_group_id is not None: + pulumi.set(__self__, "security_group_id", security_group_id) + if security_group_rule_id is not None: + pulumi.set(__self__, "security_group_rule_id", security_group_rule_id) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The rule description. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def direction(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + """ + return pulumi.get(self, "direction") + + @direction.setter + def direction(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "direction", value) + + @property + @pulumi.getter(name="etherType") + def ether_type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The ethertype which the rule should match. + """ + return pulumi.get(self, "ether_type") + + @ether_type.setter + def ether_type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ether_type", value) + + @property + @pulumi.getter(name="icmpParameters") + def icmp_parameters(self) -> Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']]: + """ + ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + """ + return pulumi.get(self, "icmp_parameters") + + @icmp_parameters.setter + def icmp_parameters(self, value: Optional[pulumi.Input['SecurityGroupRuleIcmpParametersArgs']]): + pulumi.set(self, "icmp_parameters", value) + + @property + @pulumi.getter(name="ipRange") + def ip_range(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The remote IP range which the rule should match. + """ + return pulumi.get(self, "ip_range") + + @ip_range.setter + def ip_range(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "ip_range", value) + + @property + @pulumi.getter(name="portRange") + def port_range(self) -> Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']]: + """ + The range of ports. This should only be provided if the protocol is not ICMP. + """ + return pulumi.get(self, "port_range") + + @port_range.setter + def port_range(self, value: Optional[pulumi.Input['SecurityGroupRulePortRangeArgs']]): + pulumi.set(self, "port_range", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the security group rule is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def protocol(self) -> Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']]: + """ + The internet protocol which the rule should match. + """ + return pulumi.get(self, "protocol") + + @protocol.setter + def protocol(self, value: Optional[pulumi.Input['SecurityGroupRuleProtocolArgs']]): + pulumi.set(self, "protocol", value) + + @property + @pulumi.getter(name="remoteSecurityGroupId") + def remote_security_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The remote security group which the rule should match. + """ + return pulumi.get(self, "remote_security_group_id") + + @remote_security_group_id.setter + def remote_security_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "remote_security_group_id", value) + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @security_group_id.setter + def security_group_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "security_group_id", value) + + @property + @pulumi.getter(name="securityGroupRuleId") + def security_group_rule_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The security group rule ID. + """ + return pulumi.get(self, "security_group_rule_id") + + @security_group_rule_id.setter + def security_group_rule_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "security_group_rule_id", value) + + +@pulumi.type_token("stackit:index/securityGroupRule:SecurityGroupRule") +class SecurityGroupRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + direction: Optional[pulumi.Input[builtins.str]] = None, + ether_type: Optional[pulumi.Input[builtins.str]] = None, + icmp_parameters: Optional[pulumi.Input[Union['SecurityGroupRuleIcmpParametersArgs', 'SecurityGroupRuleIcmpParametersArgsDict']]] = None, + ip_range: Optional[pulumi.Input[builtins.str]] = None, + port_range: Optional[pulumi.Input[Union['SecurityGroupRulePortRangeArgs', 'SecurityGroupRulePortRangeArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protocol: Optional[pulumi.Input[Union['SecurityGroupRuleProtocolArgs', 'SecurityGroupRuleProtocolArgsDict']]] = None, + remote_security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Security group rule resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] description: The rule description. + :param pulumi.Input[builtins.str] direction: The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + :param pulumi.Input[builtins.str] ether_type: The ethertype which the rule should match. + :param pulumi.Input[Union['SecurityGroupRuleIcmpParametersArgs', 'SecurityGroupRuleIcmpParametersArgsDict']] icmp_parameters: ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + :param pulumi.Input[builtins.str] ip_range: The remote IP range which the rule should match. + :param pulumi.Input[Union['SecurityGroupRulePortRangeArgs', 'SecurityGroupRulePortRangeArgsDict']] port_range: The range of ports. This should only be provided if the protocol is not ICMP. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group rule is associated. + :param pulumi.Input[Union['SecurityGroupRuleProtocolArgs', 'SecurityGroupRuleProtocolArgsDict']] protocol: The internet protocol which the rule should match. + :param pulumi.Input[builtins.str] remote_security_group_id: The remote security group which the rule should match. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SecurityGroupRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Security group rule resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SecurityGroupRuleArgs 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(SecurityGroupRuleArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + direction: Optional[pulumi.Input[builtins.str]] = None, + ether_type: Optional[pulumi.Input[builtins.str]] = None, + icmp_parameters: Optional[pulumi.Input[Union['SecurityGroupRuleIcmpParametersArgs', 'SecurityGroupRuleIcmpParametersArgsDict']]] = None, + ip_range: Optional[pulumi.Input[builtins.str]] = None, + port_range: Optional[pulumi.Input[Union['SecurityGroupRulePortRangeArgs', 'SecurityGroupRulePortRangeArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protocol: Optional[pulumi.Input[Union['SecurityGroupRuleProtocolArgs', 'SecurityGroupRuleProtocolArgsDict']]] = None, + remote_security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.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__ = SecurityGroupRuleArgs.__new__(SecurityGroupRuleArgs) + + __props__.__dict__["description"] = description + if direction is None and not opts.urn: + raise TypeError("Missing required property 'direction'") + __props__.__dict__["direction"] = direction + __props__.__dict__["ether_type"] = ether_type + __props__.__dict__["icmp_parameters"] = icmp_parameters + __props__.__dict__["ip_range"] = ip_range + __props__.__dict__["port_range"] = port_range + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["protocol"] = protocol + __props__.__dict__["remote_security_group_id"] = remote_security_group_id + if security_group_id is None and not opts.urn: + raise TypeError("Missing required property 'security_group_id'") + __props__.__dict__["security_group_id"] = security_group_id + __props__.__dict__["security_group_rule_id"] = None + super(SecurityGroupRule, __self__).__init__( + 'stackit:index/securityGroupRule:SecurityGroupRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + direction: Optional[pulumi.Input[builtins.str]] = None, + ether_type: Optional[pulumi.Input[builtins.str]] = None, + icmp_parameters: Optional[pulumi.Input[Union['SecurityGroupRuleIcmpParametersArgs', 'SecurityGroupRuleIcmpParametersArgsDict']]] = None, + ip_range: Optional[pulumi.Input[builtins.str]] = None, + port_range: Optional[pulumi.Input[Union['SecurityGroupRulePortRangeArgs', 'SecurityGroupRulePortRangeArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + protocol: Optional[pulumi.Input[Union['SecurityGroupRuleProtocolArgs', 'SecurityGroupRuleProtocolArgsDict']]] = None, + remote_security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_id: Optional[pulumi.Input[builtins.str]] = None, + security_group_rule_id: Optional[pulumi.Input[builtins.str]] = None) -> 'SecurityGroupRule': + """ + Get an existing SecurityGroupRule 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[builtins.str] description: The rule description. + :param pulumi.Input[builtins.str] direction: The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + :param pulumi.Input[builtins.str] ether_type: The ethertype which the rule should match. + :param pulumi.Input[Union['SecurityGroupRuleIcmpParametersArgs', 'SecurityGroupRuleIcmpParametersArgsDict']] icmp_parameters: ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + :param pulumi.Input[builtins.str] ip_range: The remote IP range which the rule should match. + :param pulumi.Input[Union['SecurityGroupRulePortRangeArgs', 'SecurityGroupRulePortRangeArgsDict']] port_range: The range of ports. This should only be provided if the protocol is not ICMP. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the security group rule is associated. + :param pulumi.Input[Union['SecurityGroupRuleProtocolArgs', 'SecurityGroupRuleProtocolArgsDict']] protocol: The internet protocol which the rule should match. + :param pulumi.Input[builtins.str] remote_security_group_id: The remote security group which the rule should match. + :param pulumi.Input[builtins.str] security_group_id: The security group ID. + :param pulumi.Input[builtins.str] security_group_rule_id: The security group rule ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SecurityGroupRuleState.__new__(_SecurityGroupRuleState) + + __props__.__dict__["description"] = description + __props__.__dict__["direction"] = direction + __props__.__dict__["ether_type"] = ether_type + __props__.__dict__["icmp_parameters"] = icmp_parameters + __props__.__dict__["ip_range"] = ip_range + __props__.__dict__["port_range"] = port_range + __props__.__dict__["project_id"] = project_id + __props__.__dict__["protocol"] = protocol + __props__.__dict__["remote_security_group_id"] = remote_security_group_id + __props__.__dict__["security_group_id"] = security_group_id + __props__.__dict__["security_group_rule_id"] = security_group_rule_id + return SecurityGroupRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The rule description. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def direction(self) -> pulumi.Output[builtins.str]: + """ + The direction of the traffic which the rule should match. Some of the possible values are: Supported values are: `ingress`, `egress`. + """ + return pulumi.get(self, "direction") + + @property + @pulumi.getter(name="etherType") + def ether_type(self) -> pulumi.Output[builtins.str]: + """ + The ethertype which the rule should match. + """ + return pulumi.get(self, "ether_type") + + @property + @pulumi.getter(name="icmpParameters") + def icmp_parameters(self) -> pulumi.Output['outputs.SecurityGroupRuleIcmpParameters']: + """ + ICMP Parameters. These parameters should only be provided if the protocol is ICMP. + """ + return pulumi.get(self, "icmp_parameters") + + @property + @pulumi.getter(name="ipRange") + def ip_range(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The remote IP range which the rule should match. + """ + return pulumi.get(self, "ip_range") + + @property + @pulumi.getter(name="portRange") + def port_range(self) -> pulumi.Output['outputs.SecurityGroupRulePortRange']: + """ + The range of ports. This should only be provided if the protocol is not ICMP. + """ + return pulumi.get(self, "port_range") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the security group rule is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def protocol(self) -> pulumi.Output['outputs.SecurityGroupRuleProtocol']: + """ + The internet protocol which the rule should match. + """ + return pulumi.get(self, "protocol") + + @property + @pulumi.getter(name="remoteSecurityGroupId") + def remote_security_group_id(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The remote security group which the rule should match. + """ + return pulumi.get(self, "remote_security_group_id") + + @property + @pulumi.getter(name="securityGroupId") + def security_group_id(self) -> pulumi.Output[builtins.str]: + """ + The security group ID. + """ + return pulumi.get(self, "security_group_id") + + @property + @pulumi.getter(name="securityGroupRuleId") + def security_group_rule_id(self) -> pulumi.Output[builtins.str]: + """ + The security group rule ID. + """ + return pulumi.get(self, "security_group_rule_id") + diff --git a/sdk/python/pulumi_stackit/server.py b/sdk/python/pulumi_stackit/server.py new file mode 100644 index 0000000..1a8ca2f --- /dev/null +++ b/sdk/python/pulumi_stackit/server.py @@ -0,0 +1,813 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ServerArgs', 'Server'] + +@pulumi.input_type +class ServerArgs: + def __init__(__self__, *, + machine_type: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + affinity_group: Optional[pulumi.Input[builtins.str]] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + boot_volume: Optional[pulumi.Input['ServerBootVolumeArgs']] = None, + desired_status: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + keypair_name: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + user_data: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a Server resource. + :param pulumi.Input[builtins.str] machine_type: Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the server is associated. + :param pulumi.Input[builtins.str] affinity_group: The affinity group the server is assigned to. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the server. + :param pulumi.Input['ServerBootVolumeArgs'] boot_volume: The boot volume for the server + :param pulumi.Input[builtins.str] desired_status: The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + :param pulumi.Input[builtins.str] image_id: The image ID to be used for an ephemeral disk on the server. + :param pulumi.Input[builtins.str] keypair_name: The name of the keypair used during server creation. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the server. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] network_interfaces: The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + :param pulumi.Input[builtins.str] user_data: User data that is passed via cloud-init to the server. + """ + pulumi.set(__self__, "machine_type", machine_type) + pulumi.set(__self__, "project_id", project_id) + if affinity_group is not None: + pulumi.set(__self__, "affinity_group", affinity_group) + if availability_zone is not None: + pulumi.set(__self__, "availability_zone", availability_zone) + if boot_volume is not None: + pulumi.set(__self__, "boot_volume", boot_volume) + if desired_status is not None: + pulumi.set(__self__, "desired_status", desired_status) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if keypair_name is not None: + pulumi.set(__self__, "keypair_name", keypair_name) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if network_interfaces is not None: + pulumi.set(__self__, "network_interfaces", network_interfaces) + if user_data is not None: + pulumi.set(__self__, "user_data", user_data) + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> pulumi.Input[builtins.str]: + """ + Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + """ + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "machine_type", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="affinityGroup") + def affinity_group(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The affinity group the server is assigned to. + """ + return pulumi.get(self, "affinity_group") + + @affinity_group.setter + def affinity_group(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "affinity_group", value) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The availability zone of the server. + """ + return pulumi.get(self, "availability_zone") + + @availability_zone.setter + def availability_zone(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "availability_zone", value) + + @property + @pulumi.getter(name="bootVolume") + def boot_volume(self) -> Optional[pulumi.Input['ServerBootVolumeArgs']]: + """ + The boot volume for the server + """ + return pulumi.get(self, "boot_volume") + + @boot_volume.setter + def boot_volume(self, value: Optional[pulumi.Input['ServerBootVolumeArgs']]): + pulumi.set(self, "boot_volume", value) + + @property + @pulumi.getter(name="desiredStatus") + def desired_status(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + """ + return pulumi.get(self, "desired_status") + + @desired_status.setter + def desired_status(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "desired_status", value) + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The image ID to be used for an ephemeral disk on the server. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_id", value) + + @property + @pulumi.getter(name="keypairName") + def keypair_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the keypair used during server creation. + """ + return pulumi.get(self, "keypair_name") + + @keypair_name.setter + def keypair_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "keypair_name", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the server. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="networkInterfaces") + def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + """ + return pulumi.get(self, "network_interfaces") + + @network_interfaces.setter + def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "network_interfaces", value) + + @property + @pulumi.getter(name="userData") + def user_data(self) -> Optional[pulumi.Input[builtins.str]]: + """ + User data that is passed via cloud-init to the server. + """ + return pulumi.get(self, "user_data") + + @user_data.setter + def user_data(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_data", value) + + +@pulumi.input_type +class _ServerState: + def __init__(__self__, *, + affinity_group: Optional[pulumi.Input[builtins.str]] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + boot_volume: Optional[pulumi.Input['ServerBootVolumeArgs']] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + desired_status: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + keypair_name: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + launched_at: Optional[pulumi.Input[builtins.str]] = None, + machine_type: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + updated_at: Optional[pulumi.Input[builtins.str]] = None, + user_data: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering Server resources. + :param pulumi.Input[builtins.str] affinity_group: The affinity group the server is assigned to. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the server. + :param pulumi.Input['ServerBootVolumeArgs'] boot_volume: The boot volume for the server + :param pulumi.Input[builtins.str] created_at: Date-time when the server was created + :param pulumi.Input[builtins.str] desired_status: The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + :param pulumi.Input[builtins.str] image_id: The image ID to be used for an ephemeral disk on the server. + :param pulumi.Input[builtins.str] keypair_name: The name of the keypair used during server creation. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] launched_at: Date-time when the server was launched + :param pulumi.Input[builtins.str] machine_type: Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + :param pulumi.Input[builtins.str] name: The name of the server. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] network_interfaces: The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the server is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] updated_at: Date-time when the server was updated + :param pulumi.Input[builtins.str] user_data: User data that is passed via cloud-init to the server. + """ + if affinity_group is not None: + pulumi.set(__self__, "affinity_group", affinity_group) + if availability_zone is not None: + pulumi.set(__self__, "availability_zone", availability_zone) + if boot_volume is not None: + pulumi.set(__self__, "boot_volume", boot_volume) + if created_at is not None: + pulumi.set(__self__, "created_at", created_at) + if desired_status is not None: + pulumi.set(__self__, "desired_status", desired_status) + if image_id is not None: + pulumi.set(__self__, "image_id", image_id) + if keypair_name is not None: + pulumi.set(__self__, "keypair_name", keypair_name) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if launched_at is not None: + pulumi.set(__self__, "launched_at", launched_at) + if machine_type is not None: + pulumi.set(__self__, "machine_type", machine_type) + if name is not None: + pulumi.set(__self__, "name", name) + if network_interfaces is not None: + pulumi.set(__self__, "network_interfaces", network_interfaces) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + if updated_at is not None: + pulumi.set(__self__, "updated_at", updated_at) + if user_data is not None: + pulumi.set(__self__, "user_data", user_data) + + @property + @pulumi.getter(name="affinityGroup") + def affinity_group(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The affinity group the server is assigned to. + """ + return pulumi.get(self, "affinity_group") + + @affinity_group.setter + def affinity_group(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "affinity_group", value) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The availability zone of the server. + """ + return pulumi.get(self, "availability_zone") + + @availability_zone.setter + def availability_zone(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "availability_zone", value) + + @property + @pulumi.getter(name="bootVolume") + def boot_volume(self) -> Optional[pulumi.Input['ServerBootVolumeArgs']]: + """ + The boot volume for the server + """ + return pulumi.get(self, "boot_volume") + + @boot_volume.setter + def boot_volume(self, value: Optional[pulumi.Input['ServerBootVolumeArgs']]): + pulumi.set(self, "boot_volume", value) + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Date-time when the server was created + """ + return pulumi.get(self, "created_at") + + @created_at.setter + def created_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "created_at", value) + + @property + @pulumi.getter(name="desiredStatus") + def desired_status(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + """ + return pulumi.get(self, "desired_status") + + @desired_status.setter + def desired_status(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "desired_status", value) + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The image ID to be used for an ephemeral disk on the server. + """ + return pulumi.get(self, "image_id") + + @image_id.setter + def image_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "image_id", value) + + @property + @pulumi.getter(name="keypairName") + def keypair_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the keypair used during server creation. + """ + return pulumi.get(self, "keypair_name") + + @keypair_name.setter + def keypair_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "keypair_name", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="launchedAt") + def launched_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Date-time when the server was launched + """ + return pulumi.get(self, "launched_at") + + @launched_at.setter + def launched_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "launched_at", value) + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + """ + return pulumi.get(self, "machine_type") + + @machine_type.setter + def machine_type(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "machine_type", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the server. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="networkInterfaces") + def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + """ + return pulumi.get(self, "network_interfaces") + + @network_interfaces.setter + def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "network_interfaces", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Date-time when the server was updated + """ + return pulumi.get(self, "updated_at") + + @updated_at.setter + def updated_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "updated_at", value) + + @property + @pulumi.getter(name="userData") + def user_data(self) -> Optional[pulumi.Input[builtins.str]]: + """ + User data that is passed via cloud-init to the server. + """ + return pulumi.get(self, "user_data") + + @user_data.setter + def user_data(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_data", value) + + +@pulumi.type_token("stackit:index/server:Server") +class Server(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + affinity_group: Optional[pulumi.Input[builtins.str]] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + boot_volume: Optional[pulumi.Input[Union['ServerBootVolumeArgs', 'ServerBootVolumeArgsDict']]] = None, + desired_status: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + keypair_name: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + machine_type: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_data: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Server resource schema. Must have a region specified in the provider configuration. + + ## Example Usage + + ### With key pair + + ### Boot from volume + + ### Boot from existing volume + + ### Network setup + + ### Server with attached volume + + ### Server with user data (cloud-init) + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] affinity_group: The affinity group the server is assigned to. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the server. + :param pulumi.Input[Union['ServerBootVolumeArgs', 'ServerBootVolumeArgsDict']] boot_volume: The boot volume for the server + :param pulumi.Input[builtins.str] desired_status: The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + :param pulumi.Input[builtins.str] image_id: The image ID to be used for an ephemeral disk on the server. + :param pulumi.Input[builtins.str] keypair_name: The name of the keypair used during server creation. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] machine_type: Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + :param pulumi.Input[builtins.str] name: The name of the server. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] network_interfaces: The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the server is associated. + :param pulumi.Input[builtins.str] user_data: User data that is passed via cloud-init to the server. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Server resource schema. Must have a region specified in the provider configuration. + + ## Example Usage + + ### With key pair + + ### Boot from volume + + ### Boot from existing volume + + ### Network setup + + ### Server with attached volume + + ### Server with user data (cloud-init) + + :param str resource_name: The name of the resource. + :param ServerArgs 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(ServerArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + affinity_group: Optional[pulumi.Input[builtins.str]] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + boot_volume: Optional[pulumi.Input[Union['ServerBootVolumeArgs', 'ServerBootVolumeArgsDict']]] = None, + desired_status: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + keypair_name: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + machine_type: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + user_data: Optional[pulumi.Input[builtins.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__ = ServerArgs.__new__(ServerArgs) + + __props__.__dict__["affinity_group"] = affinity_group + __props__.__dict__["availability_zone"] = availability_zone + __props__.__dict__["boot_volume"] = boot_volume + __props__.__dict__["desired_status"] = desired_status + __props__.__dict__["image_id"] = image_id + __props__.__dict__["keypair_name"] = keypair_name + __props__.__dict__["labels"] = labels + if machine_type is None and not opts.urn: + raise TypeError("Missing required property 'machine_type'") + __props__.__dict__["machine_type"] = machine_type + __props__.__dict__["name"] = name + __props__.__dict__["network_interfaces"] = network_interfaces + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["user_data"] = user_data + __props__.__dict__["created_at"] = None + __props__.__dict__["launched_at"] = None + __props__.__dict__["server_id"] = None + __props__.__dict__["updated_at"] = None + super(Server, __self__).__init__( + 'stackit:index/server:Server', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + affinity_group: Optional[pulumi.Input[builtins.str]] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + boot_volume: Optional[pulumi.Input[Union['ServerBootVolumeArgs', 'ServerBootVolumeArgsDict']]] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + desired_status: Optional[pulumi.Input[builtins.str]] = None, + image_id: Optional[pulumi.Input[builtins.str]] = None, + keypair_name: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + launched_at: Optional[pulumi.Input[builtins.str]] = None, + machine_type: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + updated_at: Optional[pulumi.Input[builtins.str]] = None, + user_data: Optional[pulumi.Input[builtins.str]] = None) -> 'Server': + """ + Get an existing Server 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[builtins.str] affinity_group: The affinity group the server is assigned to. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the server. + :param pulumi.Input[Union['ServerBootVolumeArgs', 'ServerBootVolumeArgsDict']] boot_volume: The boot volume for the server + :param pulumi.Input[builtins.str] created_at: Date-time when the server was created + :param pulumi.Input[builtins.str] desired_status: The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + :param pulumi.Input[builtins.str] image_id: The image ID to be used for an ephemeral disk on the server. + :param pulumi.Input[builtins.str] keypair_name: The name of the keypair used during server creation. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] launched_at: Date-time when the server was launched + :param pulumi.Input[builtins.str] machine_type: Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + :param pulumi.Input[builtins.str] name: The name of the server. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] network_interfaces: The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the server is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] updated_at: Date-time when the server was updated + :param pulumi.Input[builtins.str] user_data: User data that is passed via cloud-init to the server. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerState.__new__(_ServerState) + + __props__.__dict__["affinity_group"] = affinity_group + __props__.__dict__["availability_zone"] = availability_zone + __props__.__dict__["boot_volume"] = boot_volume + __props__.__dict__["created_at"] = created_at + __props__.__dict__["desired_status"] = desired_status + __props__.__dict__["image_id"] = image_id + __props__.__dict__["keypair_name"] = keypair_name + __props__.__dict__["labels"] = labels + __props__.__dict__["launched_at"] = launched_at + __props__.__dict__["machine_type"] = machine_type + __props__.__dict__["name"] = name + __props__.__dict__["network_interfaces"] = network_interfaces + __props__.__dict__["project_id"] = project_id + __props__.__dict__["server_id"] = server_id + __props__.__dict__["updated_at"] = updated_at + __props__.__dict__["user_data"] = user_data + return Server(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="affinityGroup") + def affinity_group(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The affinity group the server is assigned to. + """ + return pulumi.get(self, "affinity_group") + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> pulumi.Output[builtins.str]: + """ + The availability zone of the server. + """ + return pulumi.get(self, "availability_zone") + + @property + @pulumi.getter(name="bootVolume") + def boot_volume(self) -> pulumi.Output[Optional['outputs.ServerBootVolume']]: + """ + The boot volume for the server + """ + return pulumi.get(self, "boot_volume") + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> pulumi.Output[builtins.str]: + """ + Date-time when the server was created + """ + return pulumi.get(self, "created_at") + + @property + @pulumi.getter(name="desiredStatus") + def desired_status(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The desired status of the server resource. Supported values are: `active`, `inactive`, `deallocated`. + """ + return pulumi.get(self, "desired_status") + + @property + @pulumi.getter(name="imageId") + def image_id(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The image ID to be used for an ephemeral disk on the server. + """ + return pulumi.get(self, "image_id") + + @property + @pulumi.getter(name="keypairName") + def keypair_name(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The name of the keypair used during server creation. + """ + return pulumi.get(self, "keypair_name") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="launchedAt") + def launched_at(self) -> pulumi.Output[builtins.str]: + """ + Date-time when the server was launched + """ + return pulumi.get(self, "launched_at") + + @property + @pulumi.getter(name="machineType") + def machine_type(self) -> pulumi.Output[builtins.str]: + """ + Name of the type of the machine for the server. Possible values are documented in [Virtual machine flavors](https://docs.stackit.cloud/stackit/en/virtual-machine-flavors-75137231.html) + """ + return pulumi.get(self, "machine_type") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the server. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="networkInterfaces") + def network_interfaces(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]: + """ + The IDs of network interfaces which should be attached to the server. Updating it will recreate the server. + """ + return pulumi.get(self, "network_interfaces") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="updatedAt") + def updated_at(self) -> pulumi.Output[builtins.str]: + """ + Date-time when the server was updated + """ + return pulumi.get(self, "updated_at") + + @property + @pulumi.getter(name="userData") + def user_data(self) -> pulumi.Output[Optional[builtins.str]]: + """ + User data that is passed via cloud-init to the server. + """ + return pulumi.get(self, "user_data") + diff --git a/sdk/python/pulumi_stackit/server_backup_schedule.py b/sdk/python/pulumi_stackit/server_backup_schedule.py new file mode 100644 index 0000000..1c325a7 --- /dev/null +++ b/sdk/python/pulumi_stackit/server_backup_schedule.py @@ -0,0 +1,477 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ServerBackupScheduleArgs', 'ServerBackupSchedule'] + +@pulumi.input_type +class ServerBackupScheduleArgs: + def __init__(__self__, *, + backup_properties: pulumi.Input['ServerBackupScheduleBackupPropertiesArgs'], + enabled: pulumi.Input[builtins.bool], + project_id: pulumi.Input[builtins.str], + rrule: pulumi.Input[builtins.str], + server_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ServerBackupSchedule resource. + :param pulumi.Input['ServerBackupScheduleBackupPropertiesArgs'] backup_properties: Backup schedule details for the backups. + :param pulumi.Input[builtins.bool] enabled: Is the backup schedule enabled or disabled. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] rrule: Backup schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the backup schedule. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "backup_properties", backup_properties) + pulumi.set(__self__, "enabled", enabled) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "rrule", rrule) + pulumi.set(__self__, "server_id", server_id) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="backupProperties") + def backup_properties(self) -> pulumi.Input['ServerBackupScheduleBackupPropertiesArgs']: + """ + Backup schedule details for the backups. + """ + return pulumi.get(self, "backup_properties") + + @backup_properties.setter + def backup_properties(self, value: pulumi.Input['ServerBackupScheduleBackupPropertiesArgs']): + pulumi.set(self, "backup_properties", value) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[builtins.bool]: + """ + Is the backup schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rrule(self) -> pulumi.Input[builtins.str]: + """ + Backup schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @rrule.setter + def rrule(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "rrule", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Input[builtins.str]: + """ + Server ID for the backup schedule. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _ServerBackupScheduleState: + def __init__(__self__, *, + backup_properties: Optional[pulumi.Input['ServerBackupScheduleBackupPropertiesArgs']] = None, + backup_schedule_id: Optional[pulumi.Input[builtins.int]] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServerBackupSchedule resources. + :param pulumi.Input['ServerBackupScheduleBackupPropertiesArgs'] backup_properties: Backup schedule details for the backups. + :param pulumi.Input[builtins.int] backup_schedule_id: Backup schedule ID. + :param pulumi.Input[builtins.bool] enabled: Is the backup schedule enabled or disabled. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Backup schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the backup schedule. + """ + if backup_properties is not None: + pulumi.set(__self__, "backup_properties", backup_properties) + if backup_schedule_id is not None: + pulumi.set(__self__, "backup_schedule_id", backup_schedule_id) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if rrule is not None: + pulumi.set(__self__, "rrule", rrule) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter(name="backupProperties") + def backup_properties(self) -> Optional[pulumi.Input['ServerBackupScheduleBackupPropertiesArgs']]: + """ + Backup schedule details for the backups. + """ + return pulumi.get(self, "backup_properties") + + @backup_properties.setter + def backup_properties(self, value: Optional[pulumi.Input['ServerBackupScheduleBackupPropertiesArgs']]): + pulumi.set(self, "backup_properties", value) + + @property + @pulumi.getter(name="backupScheduleId") + def backup_schedule_id(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Backup schedule ID. + """ + return pulumi.get(self, "backup_schedule_id") + + @backup_schedule_id.setter + def backup_schedule_id(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "backup_schedule_id", value) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Is the backup schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def rrule(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Backup schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @rrule.setter + def rrule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "rrule", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Server ID for the backup schedule. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + +@pulumi.type_token("stackit:index/serverBackupSchedule:ServerBackupSchedule") +class ServerBackupSchedule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + backup_properties: Optional[pulumi.Input[Union['ServerBackupScheduleBackupPropertiesArgs', 'ServerBackupScheduleBackupPropertiesArgsDict']]] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Server backup schedule resource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Union['ServerBackupScheduleBackupPropertiesArgs', 'ServerBackupScheduleBackupPropertiesArgsDict']] backup_properties: Backup schedule details for the backups. + :param pulumi.Input[builtins.bool] enabled: Is the backup schedule enabled or disabled. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Backup schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the backup schedule. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerBackupScheduleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Server backup schedule resource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServerBackupScheduleArgs 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(ServerBackupScheduleArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + backup_properties: Optional[pulumi.Input[Union['ServerBackupScheduleBackupPropertiesArgs', 'ServerBackupScheduleBackupPropertiesArgsDict']]] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.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__ = ServerBackupScheduleArgs.__new__(ServerBackupScheduleArgs) + + if backup_properties is None and not opts.urn: + raise TypeError("Missing required property 'backup_properties'") + __props__.__dict__["backup_properties"] = backup_properties + if enabled is None and not opts.urn: + raise TypeError("Missing required property 'enabled'") + __props__.__dict__["enabled"] = enabled + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if rrule is None and not opts.urn: + raise TypeError("Missing required property 'rrule'") + __props__.__dict__["rrule"] = rrule + if server_id is None and not opts.urn: + raise TypeError("Missing required property 'server_id'") + __props__.__dict__["server_id"] = server_id + __props__.__dict__["backup_schedule_id"] = None + super(ServerBackupSchedule, __self__).__init__( + 'stackit:index/serverBackupSchedule:ServerBackupSchedule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + backup_properties: Optional[pulumi.Input[Union['ServerBackupScheduleBackupPropertiesArgs', 'ServerBackupScheduleBackupPropertiesArgsDict']]] = None, + backup_schedule_id: Optional[pulumi.Input[builtins.int]] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ServerBackupSchedule': + """ + Get an existing ServerBackupSchedule 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[Union['ServerBackupScheduleBackupPropertiesArgs', 'ServerBackupScheduleBackupPropertiesArgsDict']] backup_properties: Backup schedule details for the backups. + :param pulumi.Input[builtins.int] backup_schedule_id: Backup schedule ID. + :param pulumi.Input[builtins.bool] enabled: Is the backup schedule enabled or disabled. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Backup schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the backup schedule. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerBackupScheduleState.__new__(_ServerBackupScheduleState) + + __props__.__dict__["backup_properties"] = backup_properties + __props__.__dict__["backup_schedule_id"] = backup_schedule_id + __props__.__dict__["enabled"] = enabled + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["rrule"] = rrule + __props__.__dict__["server_id"] = server_id + return ServerBackupSchedule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="backupProperties") + def backup_properties(self) -> pulumi.Output['outputs.ServerBackupScheduleBackupProperties']: + """ + Backup schedule details for the backups. + """ + return pulumi.get(self, "backup_properties") + + @property + @pulumi.getter(name="backupScheduleId") + def backup_schedule_id(self) -> pulumi.Output[builtins.int]: + """ + Backup schedule ID. + """ + return pulumi.get(self, "backup_schedule_id") + + @property + @pulumi.getter + def enabled(self) -> pulumi.Output[builtins.bool]: + """ + Is the backup schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def rrule(self) -> pulumi.Output[builtins.str]: + """ + Backup schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + Server ID for the backup schedule. + """ + return pulumi.get(self, "server_id") + diff --git a/sdk/python/pulumi_stackit/server_network_interface_attach.py b/sdk/python/pulumi_stackit/server_network_interface_attach.py new file mode 100644 index 0000000..a9d3106 --- /dev/null +++ b/sdk/python/pulumi_stackit/server_network_interface_attach.py @@ -0,0 +1,253 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServerNetworkInterfaceAttachArgs', 'ServerNetworkInterfaceAttach'] + +@pulumi.input_type +class ServerNetworkInterfaceAttachArgs: + def __init__(__self__, *, + network_interface_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + server_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a ServerNetworkInterfaceAttach resource. + :param pulumi.Input[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network interface attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + """ + pulumi.set(__self__, "network_interface_id", network_interface_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Input[builtins.str]: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the network interface attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Input[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "server_id", value) + + +@pulumi.input_type +class _ServerNetworkInterfaceAttachState: + def __init__(__self__, *, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServerNetworkInterfaceAttach resources. + :param pulumi.Input[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network interface attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + """ + if network_interface_id is not None: + pulumi.set(__self__, "network_interface_id", network_interface_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @network_interface_id.setter + def network_interface_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "network_interface_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the network interface attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + +@pulumi.type_token("stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach") +class ServerNetworkInterfaceAttach(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network interface attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerNetworkInterfaceAttachArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Network interface attachment resource schema. Attaches a network interface to a server. Must have a `region` specified in the provider configuration. The attachment only takes full effect after server reboot. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServerNetworkInterfaceAttachArgs 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(ServerNetworkInterfaceAttachArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.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__ = ServerNetworkInterfaceAttachArgs.__new__(ServerNetworkInterfaceAttachArgs) + + if network_interface_id is None and not opts.urn: + raise TypeError("Missing required property 'network_interface_id'") + __props__.__dict__["network_interface_id"] = network_interface_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if server_id is None and not opts.urn: + raise TypeError("Missing required property 'server_id'") + __props__.__dict__["server_id"] = server_id + super(ServerNetworkInterfaceAttach, __self__).__init__( + 'stackit:index/serverNetworkInterfaceAttach:ServerNetworkInterfaceAttach', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + network_interface_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ServerNetworkInterfaceAttach': + """ + Get an existing ServerNetworkInterfaceAttach 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[builtins.str] network_interface_id: The network interface ID. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the network interface attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerNetworkInterfaceAttachState.__new__(_ServerNetworkInterfaceAttachState) + + __props__.__dict__["network_interface_id"] = network_interface_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["server_id"] = server_id + return ServerNetworkInterfaceAttach(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="networkInterfaceId") + def network_interface_id(self) -> pulumi.Output[builtins.str]: + """ + The network interface ID. + """ + return pulumi.get(self, "network_interface_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the network interface attachment is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + diff --git a/sdk/python/pulumi_stackit/server_service_account_attach.py b/sdk/python/pulumi_stackit/server_service_account_attach.py new file mode 100644 index 0000000..3983698 --- /dev/null +++ b/sdk/python/pulumi_stackit/server_service_account_attach.py @@ -0,0 +1,253 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServerServiceAccountAttachArgs', 'ServerServiceAccountAttach'] + +@pulumi.input_type +class ServerServiceAccountAttachArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + server_id: pulumi.Input[builtins.str], + service_account_email: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a ServerServiceAccountAttach resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] service_account_email: The service account email. + """ + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "server_id", server_id) + pulumi.set(__self__, "service_account_email", service_account_email) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the service account attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Input[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Input[builtins.str]: + """ + The service account email. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "service_account_email", value) + + +@pulumi.input_type +class _ServerServiceAccountAttachState: + def __init__(__self__, *, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServerServiceAccountAttach resources. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] service_account_email: The service account email. + """ + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + if service_account_email is not None: + pulumi.set(__self__, "service_account_email", service_account_email) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the service account attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The service account email. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_email", value) + + +@pulumi.type_token("stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach") +class ServerServiceAccountAttach(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] service_account_email: The service account email. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerServiceAccountAttachArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Service account attachment resource schema. Attaches a service account to a server. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServerServiceAccountAttachArgs 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(ServerServiceAccountAttachArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.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__ = ServerServiceAccountAttachArgs.__new__(ServerServiceAccountAttachArgs) + + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if server_id is None and not opts.urn: + raise TypeError("Missing required property 'server_id'") + __props__.__dict__["server_id"] = server_id + if service_account_email is None and not opts.urn: + raise TypeError("Missing required property 'service_account_email'") + __props__.__dict__["service_account_email"] = service_account_email + super(ServerServiceAccountAttach, __self__).__init__( + 'stackit:index/serverServiceAccountAttach:ServerServiceAccountAttach', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None) -> 'ServerServiceAccountAttach': + """ + Get an existing ServerServiceAccountAttach 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[builtins.str] project_id: STACKIT project ID to which the service account attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] service_account_email: The service account email. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerServiceAccountAttachState.__new__(_ServerServiceAccountAttachState) + + __props__.__dict__["project_id"] = project_id + __props__.__dict__["server_id"] = server_id + __props__.__dict__["service_account_email"] = service_account_email + return ServerServiceAccountAttach(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the service account attachment is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Output[builtins.str]: + """ + The service account email. + """ + return pulumi.get(self, "service_account_email") + diff --git a/sdk/python/pulumi_stackit/server_update_schedule.py b/sdk/python/pulumi_stackit/server_update_schedule.py new file mode 100644 index 0000000..972bf77 --- /dev/null +++ b/sdk/python/pulumi_stackit/server_update_schedule.py @@ -0,0 +1,475 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServerUpdateScheduleArgs', 'ServerUpdateSchedule'] + +@pulumi.input_type +class ServerUpdateScheduleArgs: + def __init__(__self__, *, + enabled: pulumi.Input[builtins.bool], + maintenance_window: pulumi.Input[builtins.int], + project_id: pulumi.Input[builtins.str], + rrule: pulumi.Input[builtins.str], + server_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ServerUpdateSchedule resource. + :param pulumi.Input[builtins.bool] enabled: Is the update schedule enabled or disabled. + :param pulumi.Input[builtins.int] maintenance_window: Maintenance window [1..24]. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] rrule: Update schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the update schedule. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "enabled", enabled) + pulumi.set(__self__, "maintenance_window", maintenance_window) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "rrule", rrule) + pulumi.set(__self__, "server_id", server_id) + if name is not None: + pulumi.set(__self__, "name", name) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Input[builtins.bool]: + """ + Is the update schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: pulumi.Input[builtins.bool]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="maintenanceWindow") + def maintenance_window(self) -> pulumi.Input[builtins.int]: + """ + Maintenance window [1..24]. + """ + return pulumi.get(self, "maintenance_window") + + @maintenance_window.setter + def maintenance_window(self, value: pulumi.Input[builtins.int]): + pulumi.set(self, "maintenance_window", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def rrule(self) -> pulumi.Input[builtins.str]: + """ + Update schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @rrule.setter + def rrule(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "rrule", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Input[builtins.str]: + """ + Server ID for the update schedule. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _ServerUpdateScheduleState: + def __init__(__self__, *, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + maintenance_window: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + update_schedule_id: Optional[pulumi.Input[builtins.int]] = None): + """ + Input properties used for looking up and filtering ServerUpdateSchedule resources. + :param pulumi.Input[builtins.bool] enabled: Is the update schedule enabled or disabled. + :param pulumi.Input[builtins.int] maintenance_window: Maintenance window [1..24]. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Update schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the update schedule. + :param pulumi.Input[builtins.int] update_schedule_id: Update schedule ID. + """ + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if maintenance_window is not None: + pulumi.set(__self__, "maintenance_window", maintenance_window) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if rrule is not None: + pulumi.set(__self__, "rrule", rrule) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + if update_schedule_id is not None: + pulumi.set(__self__, "update_schedule_id", update_schedule_id) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Is the update schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="maintenanceWindow") + def maintenance_window(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Maintenance window [1..24]. + """ + return pulumi.get(self, "maintenance_window") + + @maintenance_window.setter + def maintenance_window(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "maintenance_window", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def rrule(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Update schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @rrule.setter + def rrule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "rrule", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Server ID for the update schedule. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="updateScheduleId") + def update_schedule_id(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Update schedule ID. + """ + return pulumi.get(self, "update_schedule_id") + + @update_schedule_id.setter + def update_schedule_id(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "update_schedule_id", value) + + +@pulumi.type_token("stackit:index/serverUpdateSchedule:ServerUpdateSchedule") +class ServerUpdateSchedule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + maintenance_window: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Server update schedule resource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.bool] enabled: Is the update schedule enabled or disabled. + :param pulumi.Input[builtins.int] maintenance_window: Maintenance window [1..24]. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Update schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the update schedule. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerUpdateScheduleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Server update schedule resource schema. Must have a `region` specified in the provider configuration. + + > This resource is in beta and may be subject to breaking changes in the future. Use with caution. See our guide for how to opt-in to use beta resources. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServerUpdateScheduleArgs 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(ServerUpdateScheduleArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + maintenance_window: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.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__ = ServerUpdateScheduleArgs.__new__(ServerUpdateScheduleArgs) + + if enabled is None and not opts.urn: + raise TypeError("Missing required property 'enabled'") + __props__.__dict__["enabled"] = enabled + if maintenance_window is None and not opts.urn: + raise TypeError("Missing required property 'maintenance_window'") + __props__.__dict__["maintenance_window"] = maintenance_window + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + if rrule is None and not opts.urn: + raise TypeError("Missing required property 'rrule'") + __props__.__dict__["rrule"] = rrule + if server_id is None and not opts.urn: + raise TypeError("Missing required property 'server_id'") + __props__.__dict__["server_id"] = server_id + __props__.__dict__["update_schedule_id"] = None + super(ServerUpdateSchedule, __self__).__init__( + 'stackit:index/serverUpdateSchedule:ServerUpdateSchedule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + enabled: Optional[pulumi.Input[builtins.bool]] = None, + maintenance_window: Optional[pulumi.Input[builtins.int]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + rrule: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + update_schedule_id: Optional[pulumi.Input[builtins.int]] = None) -> 'ServerUpdateSchedule': + """ + Get an existing ServerUpdateSchedule 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[builtins.bool] enabled: Is the update schedule enabled or disabled. + :param pulumi.Input[builtins.int] maintenance_window: Maintenance window [1..24]. + :param pulumi.Input[builtins.str] name: The schedule name. + :param pulumi.Input[builtins.str] project_id: STACKIT Project ID to which the server is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + :param pulumi.Input[builtins.str] rrule: Update schedule described in `rrule` (recurrence rule) format. + :param pulumi.Input[builtins.str] server_id: Server ID for the update schedule. + :param pulumi.Input[builtins.int] update_schedule_id: Update schedule ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerUpdateScheduleState.__new__(_ServerUpdateScheduleState) + + __props__.__dict__["enabled"] = enabled + __props__.__dict__["maintenance_window"] = maintenance_window + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["rrule"] = rrule + __props__.__dict__["server_id"] = server_id + __props__.__dict__["update_schedule_id"] = update_schedule_id + return ServerUpdateSchedule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def enabled(self) -> pulumi.Output[builtins.bool]: + """ + Is the update schedule enabled or disabled. + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter(name="maintenanceWindow") + def maintenance_window(self) -> pulumi.Output[builtins.int]: + """ + Maintenance window [1..24]. + """ + return pulumi.get(self, "maintenance_window") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The schedule name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT Project ID to which the server is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def rrule(self) -> pulumi.Output[builtins.str]: + """ + Update schedule described in `rrule` (recurrence rule) format. + """ + return pulumi.get(self, "rrule") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + Server ID for the update schedule. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="updateScheduleId") + def update_schedule_id(self) -> pulumi.Output[builtins.int]: + """ + Update schedule ID. + """ + return pulumi.get(self, "update_schedule_id") + diff --git a/sdk/python/pulumi_stackit/server_volume_attach.py b/sdk/python/pulumi_stackit/server_volume_attach.py new file mode 100644 index 0000000..a7cf549 --- /dev/null +++ b/sdk/python/pulumi_stackit/server_volume_attach.py @@ -0,0 +1,253 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServerVolumeAttachArgs', 'ServerVolumeAttach'] + +@pulumi.input_type +class ServerVolumeAttachArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + server_id: pulumi.Input[builtins.str], + volume_id: pulumi.Input[builtins.str]): + """ + The set of arguments for constructing a ServerVolumeAttach resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "server_id", server_id) + pulumi.set(__self__, "volume_id", volume_id) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the volume attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Input[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> pulumi.Input[builtins.str]: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + + @volume_id.setter + def volume_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "volume_id", value) + + +@pulumi.input_type +class _ServerVolumeAttachState: + def __init__(__self__, *, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServerVolumeAttach resources. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + if volume_id is not None: + pulumi.set(__self__, "volume_id", volume_id) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the volume attachment is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + + @volume_id.setter + def volume_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "volume_id", value) + + +@pulumi.type_token("stackit:index/serverVolumeAttach:ServerVolumeAttach") +class ServerVolumeAttach(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServerVolumeAttachArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Volume attachment resource schema. Attaches a volume to a server. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServerVolumeAttachArgs 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(ServerVolumeAttachArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + volume_id: Optional[pulumi.Input[builtins.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__ = ServerVolumeAttachArgs.__new__(ServerVolumeAttachArgs) + + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + if server_id is None and not opts.urn: + raise TypeError("Missing required property 'server_id'") + __props__.__dict__["server_id"] = server_id + if volume_id is None and not opts.urn: + raise TypeError("Missing required property 'volume_id'") + __props__.__dict__["volume_id"] = volume_id + super(ServerVolumeAttach, __self__).__init__( + 'stackit:index/serverVolumeAttach:ServerVolumeAttach', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ServerVolumeAttach': + """ + Get an existing ServerVolumeAttach 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[builtins.str] project_id: STACKIT project ID to which the volume attachment is associated. + :param pulumi.Input[builtins.str] server_id: The server ID. + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServerVolumeAttachState.__new__(_ServerVolumeAttachState) + + __props__.__dict__["project_id"] = project_id + __props__.__dict__["server_id"] = server_id + __props__.__dict__["volume_id"] = volume_id + return ServerVolumeAttach(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the volume attachment is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + The server ID. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> pulumi.Output[builtins.str]: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + diff --git a/sdk/python/pulumi_stackit/service_account.py b/sdk/python/pulumi_stackit/service_account.py new file mode 100644 index 0000000..1bcb7e0 --- /dev/null +++ b/sdk/python/pulumi_stackit/service_account.py @@ -0,0 +1,232 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServiceAccountArgs', 'ServiceAccount'] + +@pulumi.input_type +class ServiceAccountArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + name: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a ServiceAccount resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account is associated. + :param pulumi.Input[builtins.str] name: Name of the service account. + """ + pulumi.set(__self__, "project_id", project_id) + if name is not None: + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the service account is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the service account. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class _ServiceAccountState: + def __init__(__self__, *, + email: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServiceAccount resources. + :param pulumi.Input[builtins.str] email: Email of the service account. + :param pulumi.Input[builtins.str] name: Name of the service account. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account is associated. + """ + if email is not None: + pulumi.set(__self__, "email", email) + if name is not None: + pulumi.set(__self__, "name", name) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + + @property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Email of the service account. + """ + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "email", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the service account. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the service account is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + +@pulumi.type_token("stackit:index/serviceAccount:ServiceAccount") +class ServiceAccount(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + Service account resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] name: Name of the service account. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account is associated. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServiceAccountArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Service account resource schema. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param ServiceAccountArgs 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(ServiceAccountArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.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__ = ServiceAccountArgs.__new__(ServiceAccountArgs) + + __props__.__dict__["name"] = name + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["email"] = None + super(ServiceAccount, __self__).__init__( + 'stackit:index/serviceAccount:ServiceAccount', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + email: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None) -> 'ServiceAccount': + """ + Get an existing ServiceAccount 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[builtins.str] email: Email of the service account. + :param pulumi.Input[builtins.str] name: Name of the service account. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the service account is associated. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServiceAccountState.__new__(_ServiceAccountState) + + __props__.__dict__["email"] = email + __props__.__dict__["name"] = name + __props__.__dict__["project_id"] = project_id + return ServiceAccount(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def email(self) -> pulumi.Output[builtins.str]: + """ + Email of the service account. + """ + return pulumi.get(self, "email") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Name of the service account. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the service account is associated. + """ + return pulumi.get(self, "project_id") + diff --git a/sdk/python/pulumi_stackit/service_account_access_token.py b/sdk/python/pulumi_stackit/service_account_access_token.py new file mode 100644 index 0000000..a87408d --- /dev/null +++ b/sdk/python/pulumi_stackit/service_account_access_token.py @@ -0,0 +1,443 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServiceAccountAccessTokenArgs', 'ServiceAccountAccessToken'] + +@pulumi.input_type +class ServiceAccountAccessTokenArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + service_account_email: pulumi.Input[builtins.str], + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None): + """ + The set of arguments for constructing a ServiceAccountAccessToken resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the service account token. + :param pulumi.Input[builtins.str] service_account_email: Email address linked to the service account. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.int] ttl_days: Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + """ + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account_email", service_account_email) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if ttl_days is not None: + pulumi.set(__self__, "ttl_days", ttl_days) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID associated with the service account token. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Input[builtins.str]: + """ + Email address linked to the service account. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "service_account_email", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + """ + return pulumi.get(self, "ttl_days") + + @ttl_days.setter + def ttl_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl_days", value) + + +@pulumi.input_type +class _ServiceAccountAccessTokenState: + def __init__(__self__, *, + access_token_id: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + token: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None, + valid_until: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering ServiceAccountAccessToken resources. + :param pulumi.Input[builtins.str] access_token_id: Identifier for the access token linked to the service account. + :param pulumi.Input[builtins.bool] active: Indicate whether the token is currently active or inactive + :param pulumi.Input[builtins.str] created_at: Timestamp indicating when the access token was created. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the service account token. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] service_account_email: Email address linked to the service account. + :param pulumi.Input[builtins.str] token: JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + :param pulumi.Input[builtins.int] ttl_days: Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + :param pulumi.Input[builtins.str] valid_until: Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + """ + if access_token_id is not None: + pulumi.set(__self__, "access_token_id", access_token_id) + if active is not None: + pulumi.set(__self__, "active", active) + if created_at is not None: + pulumi.set(__self__, "created_at", created_at) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if service_account_email is not None: + pulumi.set(__self__, "service_account_email", service_account_email) + if token is not None: + pulumi.set(__self__, "token", token) + if ttl_days is not None: + pulumi.set(__self__, "ttl_days", ttl_days) + if valid_until is not None: + pulumi.set(__self__, "valid_until", valid_until) + + @property + @pulumi.getter(name="accessTokenId") + def access_token_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Identifier for the access token linked to the service account. + """ + return pulumi.get(self, "access_token_id") + + @access_token_id.setter + def access_token_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "access_token_id", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Indicate whether the token is currently active or inactive + """ + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Timestamp indicating when the access token was created. + """ + return pulumi.get(self, "created_at") + + @created_at.setter + def created_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "created_at", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID associated with the service account token. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Email address linked to the service account. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_email", value) + + @property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[builtins.str]]: + """ + JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + """ + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "token", value) + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + """ + return pulumi.get(self, "ttl_days") + + @ttl_days.setter + def ttl_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl_days", value) + + @property + @pulumi.getter(name="validUntil") + def valid_until(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + """ + return pulumi.get(self, "valid_until") + + @valid_until.setter + def valid_until(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "valid_until", value) + + +@pulumi.type_token("stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken") +class ServiceAccountAccessToken(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None, + __props__=None): + """ + Service account access token schema. + ## Example Usage + + ### Automatically rotate access tokens + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the service account token. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] service_account_email: Email address linked to the service account. + :param pulumi.Input[builtins.int] ttl_days: Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServiceAccountAccessTokenArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Service account access token schema. + ## Example Usage + + ### Automatically rotate access tokens + + :param str resource_name: The name of the resource. + :param ServiceAccountAccessTokenArgs 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(ServiceAccountAccessTokenArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = 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__ = ServiceAccountAccessTokenArgs.__new__(ServiceAccountAccessTokenArgs) + + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + if service_account_email is None and not opts.urn: + raise TypeError("Missing required property 'service_account_email'") + __props__.__dict__["service_account_email"] = service_account_email + __props__.__dict__["ttl_days"] = ttl_days + __props__.__dict__["access_token_id"] = None + __props__.__dict__["active"] = None + __props__.__dict__["created_at"] = None + __props__.__dict__["token"] = None + __props__.__dict__["valid_until"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["token"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ServiceAccountAccessToken, __self__).__init__( + 'stackit:index/serviceAccountAccessToken:ServiceAccountAccessToken', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + access_token_id: Optional[pulumi.Input[builtins.str]] = None, + active: Optional[pulumi.Input[builtins.bool]] = None, + created_at: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + token: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None, + valid_until: Optional[pulumi.Input[builtins.str]] = None) -> 'ServiceAccountAccessToken': + """ + Get an existing ServiceAccountAccessToken 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[builtins.str] access_token_id: Identifier for the access token linked to the service account. + :param pulumi.Input[builtins.bool] active: Indicate whether the token is currently active or inactive + :param pulumi.Input[builtins.str] created_at: Timestamp indicating when the access token was created. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID associated with the service account token. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + :param pulumi.Input[builtins.str] service_account_email: Email address linked to the service account. + :param pulumi.Input[builtins.str] token: JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + :param pulumi.Input[builtins.int] ttl_days: Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + :param pulumi.Input[builtins.str] valid_until: Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServiceAccountAccessTokenState.__new__(_ServiceAccountAccessTokenState) + + __props__.__dict__["access_token_id"] = access_token_id + __props__.__dict__["active"] = active + __props__.__dict__["created_at"] = created_at + __props__.__dict__["project_id"] = project_id + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + __props__.__dict__["service_account_email"] = service_account_email + __props__.__dict__["token"] = token + __props__.__dict__["ttl_days"] = ttl_days + __props__.__dict__["valid_until"] = valid_until + return ServiceAccountAccessToken(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="accessTokenId") + def access_token_id(self) -> pulumi.Output[builtins.str]: + """ + Identifier for the access token linked to the service account. + """ + return pulumi.get(self, "access_token_id") + + @property + @pulumi.getter + def active(self) -> pulumi.Output[builtins.bool]: + """ + Indicate whether the token is currently active or inactive + """ + return pulumi.get(self, "active") + + @property + @pulumi.getter(name="createdAt") + def created_at(self) -> pulumi.Output[builtins.str]: + """ + Timestamp indicating when the access token was created. + """ + return pulumi.get(self, "created_at") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID associated with the service account token. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + A map of arbitrary key/value pairs that will force recreation of the token when they change, enabling token rotation based on external conditions such as a rotating timestamp. Changing this forces a new resource to be created. + """ + return pulumi.get(self, "rotate_when_changed") + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Output[builtins.str]: + """ + Email address linked to the service account. + """ + return pulumi.get(self, "service_account_email") + + @property + @pulumi.getter + def token(self) -> pulumi.Output[builtins.str]: + """ + JWT access token for API authentication. Prefixed by 'Bearer' and should be stored securely as it is irretrievable once lost. + """ + return pulumi.get(self, "token") + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> pulumi.Output[builtins.int]: + """ + Specifies the token's validity duration in days. If unspecified, defaults to 90 days. + """ + return pulumi.get(self, "ttl_days") + + @property + @pulumi.getter(name="validUntil") + def valid_until(self) -> pulumi.Output[builtins.str]: + """ + Estimated expiration timestamp of the access token. For precise validity, check the JWT details. + """ + return pulumi.get(self, "valid_until") + diff --git a/sdk/python/pulumi_stackit/service_account_key.py b/sdk/python/pulumi_stackit/service_account_key.py new file mode 100644 index 0000000..bca9a4a --- /dev/null +++ b/sdk/python/pulumi_stackit/service_account_key.py @@ -0,0 +1,406 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['ServiceAccountKeyArgs', 'ServiceAccountKey'] + +@pulumi.input_type +class ServiceAccountKeyArgs: + def __init__(__self__, *, + project_id: pulumi.Input[builtins.str], + service_account_email: pulumi.Input[builtins.str], + public_key: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None): + """ + The set of arguments for constructing a ServiceAccountKey resource. + :param pulumi.Input[builtins.str] project_id: The STACKIT project ID associated with the service account key. + :param pulumi.Input[builtins.str] service_account_email: The email address associated with the service account, used for account identification and communication. + :param pulumi.Input[builtins.str] public_key: Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + :param pulumi.Input[builtins.int] ttl_days: Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "service_account_email", service_account_email) + if public_key is not None: + pulumi.set(__self__, "public_key", public_key) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if ttl_days is not None: + pulumi.set(__self__, "ttl_days", ttl_days) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + The STACKIT project ID associated with the service account key. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Input[builtins.str]: + """ + The email address associated with the service account, used for account identification and communication. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "service_account_email", value) + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + """ + return pulumi.get(self, "public_key") + + @public_key.setter + def public_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_key", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + return pulumi.get(self, "ttl_days") + + @ttl_days.setter + def ttl_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl_days", value) + + +@pulumi.input_type +class _ServiceAccountKeyState: + def __init__(__self__, *, + json: Optional[pulumi.Input[builtins.str]] = None, + key_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None): + """ + Input properties used for looking up and filtering ServiceAccountKey resources. + :param pulumi.Input[builtins.str] json: The raw JSON representation of the service account key json, available for direct use. + :param pulumi.Input[builtins.str] key_id: The unique identifier for the key associated with the service account. + :param pulumi.Input[builtins.str] project_id: The STACKIT project ID associated with the service account key. + :param pulumi.Input[builtins.str] public_key: Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + :param pulumi.Input[builtins.str] service_account_email: The email address associated with the service account, used for account identification and communication. + :param pulumi.Input[builtins.int] ttl_days: Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + if json is not None: + pulumi.set(__self__, "json", json) + if key_id is not None: + pulumi.set(__self__, "key_id", key_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if public_key is not None: + pulumi.set(__self__, "public_key", public_key) + if rotate_when_changed is not None: + pulumi.set(__self__, "rotate_when_changed", rotate_when_changed) + if service_account_email is not None: + pulumi.set(__self__, "service_account_email", service_account_email) + if ttl_days is not None: + pulumi.set(__self__, "ttl_days", ttl_days) + + @property + @pulumi.getter + def json(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The raw JSON representation of the service account key json, available for direct use. + """ + return pulumi.get(self, "json") + + @json.setter + def json(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "json", value) + + @property + @pulumi.getter(name="keyId") + def key_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The unique identifier for the key associated with the service account. + """ + return pulumi.get(self, "key_id") + + @key_id.setter + def key_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "key_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The STACKIT project ID associated with the service account key. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + """ + return pulumi.get(self, "public_key") + + @public_key.setter + def public_key(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "public_key", value) + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + """ + return pulumi.get(self, "rotate_when_changed") + + @rotate_when_changed.setter + def rotate_when_changed(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "rotate_when_changed", value) + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The email address associated with the service account, used for account identification and communication. + """ + return pulumi.get(self, "service_account_email") + + @service_account_email.setter + def service_account_email(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "service_account_email", value) + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + return pulumi.get(self, "ttl_days") + + @ttl_days.setter + def ttl_days(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "ttl_days", value) + + +@pulumi.type_token("stackit:index/serviceAccountKey:ServiceAccountKey") +class ServiceAccountKey(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None, + __props__=None): + """ + Service account key schema. + ## Example Usage + + ### Automatically rotate service account keys + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] project_id: The STACKIT project ID associated with the service account key. + :param pulumi.Input[builtins.str] public_key: Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + :param pulumi.Input[builtins.str] service_account_email: The email address associated with the service account, used for account identification and communication. + :param pulumi.Input[builtins.int] ttl_days: Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServiceAccountKeyArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Service account key schema. + ## Example Usage + + ### Automatically rotate service account keys + + :param str resource_name: The name of the resource. + :param ServiceAccountKeyArgs 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(ServiceAccountKeyArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = 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__ = ServiceAccountKeyArgs.__new__(ServiceAccountKeyArgs) + + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["public_key"] = public_key + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + if service_account_email is None and not opts.urn: + raise TypeError("Missing required property 'service_account_email'") + __props__.__dict__["service_account_email"] = service_account_email + __props__.__dict__["ttl_days"] = ttl_days + __props__.__dict__["json"] = None + __props__.__dict__["key_id"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["json"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ServiceAccountKey, __self__).__init__( + 'stackit:index/serviceAccountKey:ServiceAccountKey', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + json: Optional[pulumi.Input[builtins.str]] = None, + key_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + public_key: Optional[pulumi.Input[builtins.str]] = None, + rotate_when_changed: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + service_account_email: Optional[pulumi.Input[builtins.str]] = None, + ttl_days: Optional[pulumi.Input[builtins.int]] = None) -> 'ServiceAccountKey': + """ + Get an existing ServiceAccountKey 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[builtins.str] json: The raw JSON representation of the service account key json, available for direct use. + :param pulumi.Input[builtins.str] key_id: The unique identifier for the key associated with the service account. + :param pulumi.Input[builtins.str] project_id: The STACKIT project ID associated with the service account key. + :param pulumi.Input[builtins.str] public_key: Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] rotate_when_changed: A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + :param pulumi.Input[builtins.str] service_account_email: The email address associated with the service account, used for account identification and communication. + :param pulumi.Input[builtins.int] ttl_days: Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServiceAccountKeyState.__new__(_ServiceAccountKeyState) + + __props__.__dict__["json"] = json + __props__.__dict__["key_id"] = key_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["public_key"] = public_key + __props__.__dict__["rotate_when_changed"] = rotate_when_changed + __props__.__dict__["service_account_email"] = service_account_email + __props__.__dict__["ttl_days"] = ttl_days + return ServiceAccountKey(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def json(self) -> pulumi.Output[builtins.str]: + """ + The raw JSON representation of the service account key json, available for direct use. + """ + return pulumi.get(self, "json") + + @property + @pulumi.getter(name="keyId") + def key_id(self) -> pulumi.Output[builtins.str]: + """ + The unique identifier for the key associated with the service account. + """ + return pulumi.get(self, "key_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + The STACKIT project ID associated with the service account key. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="publicKey") + def public_key(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Specifies the public*key (RSA2048 key-pair). If not provided, a certificate from STACKIT will be used to generate a private*key. + """ + return pulumi.get(self, "public_key") + + @property + @pulumi.getter(name="rotateWhenChanged") + def rotate_when_changed(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + A map of arbitrary key/value pairs designed to force key recreation when they change, facilitating key rotation based on external factors such as a changing timestamp. Modifying this map triggers the creation of a new resource. + """ + return pulumi.get(self, "rotate_when_changed") + + @property + @pulumi.getter(name="serviceAccountEmail") + def service_account_email(self) -> pulumi.Output[builtins.str]: + """ + The email address associated with the service account, used for account identification and communication. + """ + return pulumi.get(self, "service_account_email") + + @property + @pulumi.getter(name="ttlDays") + def ttl_days(self) -> pulumi.Output[Optional[builtins.int]]: + """ + Specifies the key's validity duration in days. If left unspecified, the key is considered valid until it is deleted + """ + return pulumi.get(self, "ttl_days") + diff --git a/sdk/python/pulumi_stackit/ske_cluster.py b/sdk/python/pulumi_stackit/ske_cluster.py new file mode 100644 index 0000000..43380a4 --- /dev/null +++ b/sdk/python/pulumi_stackit/ske_cluster.py @@ -0,0 +1,713 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['SkeClusterArgs', 'SkeCluster'] + +@pulumi.input_type +class SkeClusterArgs: + def __init__(__self__, *, + node_pools: pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]], + project_id: pulumi.Input[builtins.str], + allow_privileged_containers: Optional[pulumi.Input[builtins.bool]] = None, + extensions: Optional[pulumi.Input['SkeClusterExtensionsArgs']] = None, + hibernations: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]] = None, + kubernetes_version: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_min: Optional[pulumi.Input[builtins.str]] = None, + maintenance: Optional[pulumi.Input['SkeClusterMaintenanceArgs']] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network: Optional[pulumi.Input['SkeClusterNetworkArgs']] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a SkeCluster resource. + :param pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]] node_pools: One or more `node_pool` block as defined below. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.bool] allow_privileged_containers: Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + :param pulumi.Input['SkeClusterExtensionsArgs'] extensions: A single extensions block as defined below. + :param pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]] hibernations: One or more hibernation block as defined below. + :param pulumi.Input[builtins.str] kubernetes_version: Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + :param pulumi.Input[builtins.str] kubernetes_version_min: The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + :param pulumi.Input['SkeClusterMaintenanceArgs'] maintenance: A single maintenance block as defined below. + :param pulumi.Input[builtins.str] name: The cluster name. + :param pulumi.Input['SkeClusterNetworkArgs'] network: Network block as defined below. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "node_pools", node_pools) + pulumi.set(__self__, "project_id", project_id) + if allow_privileged_containers is not None: + pulumi.set(__self__, "allow_privileged_containers", allow_privileged_containers) + if extensions is not None: + pulumi.set(__self__, "extensions", extensions) + if hibernations is not None: + pulumi.set(__self__, "hibernations", hibernations) + if kubernetes_version is not None: + warnings.warn("""Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""", DeprecationWarning) + pulumi.log.warn("""kubernetes_version is deprecated: Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""") + if kubernetes_version is not None: + pulumi.set(__self__, "kubernetes_version", kubernetes_version) + if kubernetes_version_min is not None: + pulumi.set(__self__, "kubernetes_version_min", kubernetes_version_min) + if maintenance is not None: + pulumi.set(__self__, "maintenance", maintenance) + if name is not None: + pulumi.set(__self__, "name", name) + if network is not None: + pulumi.set(__self__, "network", network) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="nodePools") + def node_pools(self) -> pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]]: + """ + One or more `node_pool` block as defined below. + """ + return pulumi.get(self, "node_pools") + + @node_pools.setter + def node_pools(self, value: pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]]): + pulumi.set(self, "node_pools", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="allowPrivilegedContainers") + def allow_privileged_containers(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + """ + return pulumi.get(self, "allow_privileged_containers") + + @allow_privileged_containers.setter + def allow_privileged_containers(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "allow_privileged_containers", value) + + @property + @pulumi.getter + def extensions(self) -> Optional[pulumi.Input['SkeClusterExtensionsArgs']]: + """ + A single extensions block as defined below. + """ + return pulumi.get(self, "extensions") + + @extensions.setter + def extensions(self, value: Optional[pulumi.Input['SkeClusterExtensionsArgs']]): + pulumi.set(self, "extensions", value) + + @property + @pulumi.getter + def hibernations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]]: + """ + One or more hibernation block as defined below. + """ + return pulumi.get(self, "hibernations") + + @hibernations.setter + def hibernations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]]): + pulumi.set(self, "hibernations", value) + + @property + @pulumi.getter(name="kubernetesVersion") + @_utilities.deprecated("""Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""") + def kubernetes_version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + """ + return pulumi.get(self, "kubernetes_version") + + @kubernetes_version.setter + def kubernetes_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kubernetes_version", value) + + @property + @pulumi.getter(name="kubernetesVersionMin") + def kubernetes_version_min(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + """ + return pulumi.get(self, "kubernetes_version_min") + + @kubernetes_version_min.setter + def kubernetes_version_min(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kubernetes_version_min", value) + + @property + @pulumi.getter + def maintenance(self) -> Optional[pulumi.Input['SkeClusterMaintenanceArgs']]: + """ + A single maintenance block as defined below. + """ + return pulumi.get(self, "maintenance") + + @maintenance.setter + def maintenance(self, value: Optional[pulumi.Input['SkeClusterMaintenanceArgs']]): + pulumi.set(self, "maintenance", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The cluster name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def network(self) -> Optional[pulumi.Input['SkeClusterNetworkArgs']]: + """ + Network block as defined below. + """ + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input['SkeClusterNetworkArgs']]): + pulumi.set(self, "network", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.input_type +class _SkeClusterState: + def __init__(__self__, *, + allow_privileged_containers: Optional[pulumi.Input[builtins.bool]] = None, + egress_address_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + extensions: Optional[pulumi.Input['SkeClusterExtensionsArgs']] = None, + hibernations: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]] = None, + kubernetes_version: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_min: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_used: Optional[pulumi.Input[builtins.str]] = None, + maintenance: Optional[pulumi.Input['SkeClusterMaintenanceArgs']] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network: Optional[pulumi.Input['SkeClusterNetworkArgs']] = None, + node_pools: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering SkeCluster resources. + :param pulumi.Input[builtins.bool] allow_privileged_containers: Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] egress_address_ranges: The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + :param pulumi.Input['SkeClusterExtensionsArgs'] extensions: A single extensions block as defined below. + :param pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]] hibernations: One or more hibernation block as defined below. + :param pulumi.Input[builtins.str] kubernetes_version: Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + :param pulumi.Input[builtins.str] kubernetes_version_min: The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + :param pulumi.Input[builtins.str] kubernetes_version_used: Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param pulumi.Input['SkeClusterMaintenanceArgs'] maintenance: A single maintenance block as defined below. + :param pulumi.Input[builtins.str] name: The cluster name. + :param pulumi.Input['SkeClusterNetworkArgs'] network: Network block as defined below. + :param pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]] node_pools: One or more `node_pool` block as defined below. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if allow_privileged_containers is not None: + pulumi.set(__self__, "allow_privileged_containers", allow_privileged_containers) + if egress_address_ranges is not None: + pulumi.set(__self__, "egress_address_ranges", egress_address_ranges) + if extensions is not None: + pulumi.set(__self__, "extensions", extensions) + if hibernations is not None: + pulumi.set(__self__, "hibernations", hibernations) + if kubernetes_version is not None: + warnings.warn("""Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""", DeprecationWarning) + pulumi.log.warn("""kubernetes_version is deprecated: Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""") + if kubernetes_version is not None: + pulumi.set(__self__, "kubernetes_version", kubernetes_version) + if kubernetes_version_min is not None: + pulumi.set(__self__, "kubernetes_version_min", kubernetes_version_min) + if kubernetes_version_used is not None: + pulumi.set(__self__, "kubernetes_version_used", kubernetes_version_used) + if maintenance is not None: + pulumi.set(__self__, "maintenance", maintenance) + if name is not None: + pulumi.set(__self__, "name", name) + if network is not None: + pulumi.set(__self__, "network", network) + if node_pools is not None: + pulumi.set(__self__, "node_pools", node_pools) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + + @property + @pulumi.getter(name="allowPrivilegedContainers") + def allow_privileged_containers(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + """ + return pulumi.get(self, "allow_privileged_containers") + + @allow_privileged_containers.setter + def allow_privileged_containers(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "allow_privileged_containers", value) + + @property + @pulumi.getter(name="egressAddressRanges") + def egress_address_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + """ + return pulumi.get(self, "egress_address_ranges") + + @egress_address_ranges.setter + def egress_address_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "egress_address_ranges", value) + + @property + @pulumi.getter + def extensions(self) -> Optional[pulumi.Input['SkeClusterExtensionsArgs']]: + """ + A single extensions block as defined below. + """ + return pulumi.get(self, "extensions") + + @extensions.setter + def extensions(self, value: Optional[pulumi.Input['SkeClusterExtensionsArgs']]): + pulumi.set(self, "extensions", value) + + @property + @pulumi.getter + def hibernations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]]: + """ + One or more hibernation block as defined below. + """ + return pulumi.get(self, "hibernations") + + @hibernations.setter + def hibernations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterHibernationArgs']]]]): + pulumi.set(self, "hibernations", value) + + @property + @pulumi.getter(name="kubernetesVersion") + @_utilities.deprecated("""Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""") + def kubernetes_version(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + """ + return pulumi.get(self, "kubernetes_version") + + @kubernetes_version.setter + def kubernetes_version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kubernetes_version", value) + + @property + @pulumi.getter(name="kubernetesVersionMin") + def kubernetes_version_min(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + """ + return pulumi.get(self, "kubernetes_version_min") + + @kubernetes_version_min.setter + def kubernetes_version_min(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kubernetes_version_min", value) + + @property + @pulumi.getter(name="kubernetesVersionUsed") + def kubernetes_version_used(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "kubernetes_version_used") + + @kubernetes_version_used.setter + def kubernetes_version_used(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kubernetes_version_used", value) + + @property + @pulumi.getter + def maintenance(self) -> Optional[pulumi.Input['SkeClusterMaintenanceArgs']]: + """ + A single maintenance block as defined below. + """ + return pulumi.get(self, "maintenance") + + @maintenance.setter + def maintenance(self, value: Optional[pulumi.Input['SkeClusterMaintenanceArgs']]): + pulumi.set(self, "maintenance", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The cluster name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def network(self) -> Optional[pulumi.Input['SkeClusterNetworkArgs']]: + """ + Network block as defined below. + """ + return pulumi.get(self, "network") + + @network.setter + def network(self, value: Optional[pulumi.Input['SkeClusterNetworkArgs']]): + pulumi.set(self, "network", value) + + @property + @pulumi.getter(name="nodePools") + def node_pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]]]: + """ + One or more `node_pool` block as defined below. + """ + return pulumi.get(self, "node_pools") + + @node_pools.setter + def node_pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SkeClusterNodePoolArgs']]]]): + pulumi.set(self, "node_pools", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + +@pulumi.type_token("stackit:index/skeCluster:SkeCluster") +class SkeCluster(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + allow_privileged_containers: Optional[pulumi.Input[builtins.bool]] = None, + extensions: Optional[pulumi.Input[Union['SkeClusterExtensionsArgs', 'SkeClusterExtensionsArgsDict']]] = None, + hibernations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterHibernationArgs', 'SkeClusterHibernationArgsDict']]]]] = None, + kubernetes_version: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_min: Optional[pulumi.Input[builtins.str]] = None, + maintenance: Optional[pulumi.Input[Union['SkeClusterMaintenanceArgs', 'SkeClusterMaintenanceArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network: Optional[pulumi.Input[Union['SkeClusterNetworkArgs', 'SkeClusterNetworkArgsDict']]] = None, + node_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterNodePoolArgs', 'SkeClusterNodePoolArgsDict']]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + SKE Cluster Resource schema. Must have a `region` specified in the provider configuration. + + > When updating `node_pools` of a `SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.bool] allow_privileged_containers: Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + :param pulumi.Input[Union['SkeClusterExtensionsArgs', 'SkeClusterExtensionsArgsDict']] extensions: A single extensions block as defined below. + :param pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterHibernationArgs', 'SkeClusterHibernationArgsDict']]]] hibernations: One or more hibernation block as defined below. + :param pulumi.Input[builtins.str] kubernetes_version: Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + :param pulumi.Input[builtins.str] kubernetes_version_min: The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + :param pulumi.Input[Union['SkeClusterMaintenanceArgs', 'SkeClusterMaintenanceArgsDict']] maintenance: A single maintenance block as defined below. + :param pulumi.Input[builtins.str] name: The cluster name. + :param pulumi.Input[Union['SkeClusterNetworkArgs', 'SkeClusterNetworkArgsDict']] network: Network block as defined below. + :param pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterNodePoolArgs', 'SkeClusterNodePoolArgsDict']]]] node_pools: One or more `node_pool` block as defined below. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SkeClusterArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + SKE Cluster Resource schema. Must have a `region` specified in the provider configuration. + + > When updating `node_pools` of a `SkeCluster`, the pulumi preview might appear incorrect as it matches the node pools by index rather than by name. However, the SKE API correctly identifies node pools by name and applies the intended changes. Please review your changes carefully to ensure the correct configuration will be applied. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SkeClusterArgs 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(SkeClusterArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + allow_privileged_containers: Optional[pulumi.Input[builtins.bool]] = None, + extensions: Optional[pulumi.Input[Union['SkeClusterExtensionsArgs', 'SkeClusterExtensionsArgsDict']]] = None, + hibernations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterHibernationArgs', 'SkeClusterHibernationArgsDict']]]]] = None, + kubernetes_version: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_min: Optional[pulumi.Input[builtins.str]] = None, + maintenance: Optional[pulumi.Input[Union['SkeClusterMaintenanceArgs', 'SkeClusterMaintenanceArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network: Optional[pulumi.Input[Union['SkeClusterNetworkArgs', 'SkeClusterNetworkArgsDict']]] = None, + node_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterNodePoolArgs', 'SkeClusterNodePoolArgsDict']]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.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__ = SkeClusterArgs.__new__(SkeClusterArgs) + + __props__.__dict__["allow_privileged_containers"] = allow_privileged_containers + __props__.__dict__["extensions"] = extensions + __props__.__dict__["hibernations"] = hibernations + __props__.__dict__["kubernetes_version"] = kubernetes_version + __props__.__dict__["kubernetes_version_min"] = kubernetes_version_min + __props__.__dict__["maintenance"] = maintenance + __props__.__dict__["name"] = name + __props__.__dict__["network"] = network + if node_pools is None and not opts.urn: + raise TypeError("Missing required property 'node_pools'") + __props__.__dict__["node_pools"] = node_pools + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["egress_address_ranges"] = None + __props__.__dict__["kubernetes_version_used"] = None + super(SkeCluster, __self__).__init__( + 'stackit:index/skeCluster:SkeCluster', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + allow_privileged_containers: Optional[pulumi.Input[builtins.bool]] = None, + egress_address_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + extensions: Optional[pulumi.Input[Union['SkeClusterExtensionsArgs', 'SkeClusterExtensionsArgsDict']]] = None, + hibernations: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterHibernationArgs', 'SkeClusterHibernationArgsDict']]]]] = None, + kubernetes_version: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_min: Optional[pulumi.Input[builtins.str]] = None, + kubernetes_version_used: Optional[pulumi.Input[builtins.str]] = None, + maintenance: Optional[pulumi.Input[Union['SkeClusterMaintenanceArgs', 'SkeClusterMaintenanceArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + network: Optional[pulumi.Input[Union['SkeClusterNetworkArgs', 'SkeClusterNetworkArgsDict']]] = None, + node_pools: Optional[pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterNodePoolArgs', 'SkeClusterNodePoolArgsDict']]]]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None) -> 'SkeCluster': + """ + Get an existing SkeCluster 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[builtins.bool] allow_privileged_containers: Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] egress_address_ranges: The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + :param pulumi.Input[Union['SkeClusterExtensionsArgs', 'SkeClusterExtensionsArgsDict']] extensions: A single extensions block as defined below. + :param pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterHibernationArgs', 'SkeClusterHibernationArgsDict']]]] hibernations: One or more hibernation block as defined below. + :param pulumi.Input[builtins.str] kubernetes_version: Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + :param pulumi.Input[builtins.str] kubernetes_version_min: The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + :param pulumi.Input[builtins.str] kubernetes_version_used: Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + :param pulumi.Input[Union['SkeClusterMaintenanceArgs', 'SkeClusterMaintenanceArgsDict']] maintenance: A single maintenance block as defined below. + :param pulumi.Input[builtins.str] name: The cluster name. + :param pulumi.Input[Union['SkeClusterNetworkArgs', 'SkeClusterNetworkArgsDict']] network: Network block as defined below. + :param pulumi.Input[Sequence[pulumi.Input[Union['SkeClusterNodePoolArgs', 'SkeClusterNodePoolArgsDict']]]] node_pools: One or more `node_pool` block as defined below. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SkeClusterState.__new__(_SkeClusterState) + + __props__.__dict__["allow_privileged_containers"] = allow_privileged_containers + __props__.__dict__["egress_address_ranges"] = egress_address_ranges + __props__.__dict__["extensions"] = extensions + __props__.__dict__["hibernations"] = hibernations + __props__.__dict__["kubernetes_version"] = kubernetes_version + __props__.__dict__["kubernetes_version_min"] = kubernetes_version_min + __props__.__dict__["kubernetes_version_used"] = kubernetes_version_used + __props__.__dict__["maintenance"] = maintenance + __props__.__dict__["name"] = name + __props__.__dict__["network"] = network + __props__.__dict__["node_pools"] = node_pools + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + return SkeCluster(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="allowPrivilegedContainers") + def allow_privileged_containers(self) -> pulumi.Output[Optional[builtins.bool]]: + """ + Flag to specify if privileged mode for containers is enabled or not. + This should be used with care since it also disables a couple of other features like the use of some volume type (e.g. PVCs). + Deprecated as of Kubernetes 1.25 and later + """ + return pulumi.get(self, "allow_privileged_containers") + + @property + @pulumi.getter(name="egressAddressRanges") + def egress_address_ranges(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The outgoing network ranges (in CIDR notation) of traffic originating from workload on the cluster. + """ + return pulumi.get(self, "egress_address_ranges") + + @property + @pulumi.getter + def extensions(self) -> pulumi.Output[Optional['outputs.SkeClusterExtensions']]: + """ + A single extensions block as defined below. + """ + return pulumi.get(self, "extensions") + + @property + @pulumi.getter + def hibernations(self) -> pulumi.Output[Optional[Sequence['outputs.SkeClusterHibernation']]]: + """ + One or more hibernation block as defined below. + """ + return pulumi.get(self, "hibernations") + + @property + @pulumi.getter(name="kubernetesVersion") + @_utilities.deprecated("""Use `kubernetes_version_min instead`. Setting a specific kubernetes version would cause errors during minor version upgrades due to forced updates. In those cases, this field might not represent the actual kubernetes version used in the cluster.""") + def kubernetes_version(self) -> pulumi.Output[Optional[builtins.str]]: + """ + Kubernetes version. Must only contain major and minor version (e.g. 1.22). This field is deprecated, use `kubernetes_version_min instead` + """ + return pulumi.get(self, "kubernetes_version") + + @property + @pulumi.getter(name="kubernetesVersionMin") + def kubernetes_version_min(self) -> pulumi.Output[Optional[builtins.str]]: + """ + The minimum Kubernetes version. This field will be used to set the minimum kubernetes version on creation/update of the cluster. If unset, the latest supported Kubernetes version will be used. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). To get the current kubernetes version being used for your cluster, use the read-only `kubernetes_version_used` field. + """ + return pulumi.get(self, "kubernetes_version_min") + + @property + @pulumi.getter(name="kubernetesVersionUsed") + def kubernetes_version_used(self) -> pulumi.Output[builtins.str]: + """ + Full Kubernetes version used. For example, if 1.22 was set in `kubernetes_version_min`, this value may result to 1.22.15. SKE automatically updates the cluster Kubernetes version if you have set `maintenance.enable_kubernetes_version_updates` to true or if there is a mandatory update, as described in [Updates for Kubernetes versions and Operating System versions in SKE](https://docs.stackit.cloud/stackit/en/version-updates-in-ske-10125631.html). + """ + return pulumi.get(self, "kubernetes_version_used") + + @property + @pulumi.getter + def maintenance(self) -> pulumi.Output['outputs.SkeClusterMaintenance']: + """ + A single maintenance block as defined below. + """ + return pulumi.get(self, "maintenance") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The cluster name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def network(self) -> pulumi.Output[Optional['outputs.SkeClusterNetwork']]: + """ + Network block as defined below. + """ + return pulumi.get(self, "network") + + @property + @pulumi.getter(name="nodePools") + def node_pools(self) -> pulumi.Output[Sequence['outputs.SkeClusterNodePool']]: + """ + One or more `node_pool` block as defined below. + """ + return pulumi.get(self, "node_pools") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + diff --git a/sdk/python/pulumi_stackit/ske_kubeconfig.py b/sdk/python/pulumi_stackit/ske_kubeconfig.py new file mode 100644 index 0000000..647ba52 --- /dev/null +++ b/sdk/python/pulumi_stackit/ske_kubeconfig.py @@ -0,0 +1,405 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['SkeKubeconfigArgs', 'SkeKubeconfig'] + +@pulumi.input_type +class SkeKubeconfigArgs: + def __init__(__self__, *, + cluster_name: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + expiration: Optional[pulumi.Input[builtins.int]] = None, + refresh: Optional[pulumi.Input[builtins.bool]] = None): + """ + The set of arguments for constructing a SkeKubeconfig resource. + :param pulumi.Input[builtins.str] cluster_name: Name of the SKE cluster. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.int] expiration: Expiration time of the kubeconfig, in seconds. Defaults to `3600` + :param pulumi.Input[builtins.bool] refresh: If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + pulumi.set(__self__, "cluster_name", cluster_name) + pulumi.set(__self__, "project_id", project_id) + if expiration is not None: + pulumi.set(__self__, "expiration", expiration) + if refresh is not None: + pulumi.set(__self__, "refresh", refresh) + + @property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> pulumi.Input[builtins.str]: + """ + Name of the SKE cluster. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "cluster_name", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def expiration(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Expiration time of the kubeconfig, in seconds. Defaults to `3600` + """ + return pulumi.get(self, "expiration") + + @expiration.setter + def expiration(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "expiration", value) + + @property + @pulumi.getter + def refresh(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + return pulumi.get(self, "refresh") + + @refresh.setter + def refresh(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "refresh", value) + + +@pulumi.input_type +class _SkeKubeconfigState: + def __init__(__self__, *, + cluster_name: Optional[pulumi.Input[builtins.str]] = None, + creation_time: Optional[pulumi.Input[builtins.str]] = None, + expiration: Optional[pulumi.Input[builtins.int]] = None, + expires_at: Optional[pulumi.Input[builtins.str]] = None, + kube_config: Optional[pulumi.Input[builtins.str]] = None, + kube_config_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh: Optional[pulumi.Input[builtins.bool]] = None): + """ + Input properties used for looking up and filtering SkeKubeconfig resources. + :param pulumi.Input[builtins.str] cluster_name: Name of the SKE cluster. + :param pulumi.Input[builtins.str] creation_time: Date-time when the kubeconfig was created + :param pulumi.Input[builtins.int] expiration: Expiration time of the kubeconfig, in seconds. Defaults to `3600` + :param pulumi.Input[builtins.str] expires_at: Timestamp when the kubeconfig expires + :param pulumi.Input[builtins.str] kube_config: Raw short-lived admin kubeconfig. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.bool] refresh: If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + if cluster_name is not None: + pulumi.set(__self__, "cluster_name", cluster_name) + if creation_time is not None: + pulumi.set(__self__, "creation_time", creation_time) + if expiration is not None: + pulumi.set(__self__, "expiration", expiration) + if expires_at is not None: + pulumi.set(__self__, "expires_at", expires_at) + if kube_config is not None: + pulumi.set(__self__, "kube_config", kube_config) + if kube_config_id is not None: + pulumi.set(__self__, "kube_config_id", kube_config_id) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if refresh is not None: + pulumi.set(__self__, "refresh", refresh) + + @property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Name of the SKE cluster. + """ + return pulumi.get(self, "cluster_name") + + @cluster_name.setter + def cluster_name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "cluster_name", value) + + @property + @pulumi.getter(name="creationTime") + def creation_time(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Date-time when the kubeconfig was created + """ + return pulumi.get(self, "creation_time") + + @creation_time.setter + def creation_time(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "creation_time", value) + + @property + @pulumi.getter + def expiration(self) -> Optional[pulumi.Input[builtins.int]]: + """ + Expiration time of the kubeconfig, in seconds. Defaults to `3600` + """ + return pulumi.get(self, "expiration") + + @expiration.setter + def expiration(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "expiration", value) + + @property + @pulumi.getter(name="expiresAt") + def expires_at(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Timestamp when the kubeconfig expires + """ + return pulumi.get(self, "expires_at") + + @expires_at.setter + def expires_at(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "expires_at", value) + + @property + @pulumi.getter(name="kubeConfig") + def kube_config(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Raw short-lived admin kubeconfig. + """ + return pulumi.get(self, "kube_config") + + @kube_config.setter + def kube_config(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kube_config", value) + + @property + @pulumi.getter(name="kubeConfigId") + def kube_config_id(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "kube_config_id") + + @kube_config_id.setter + def kube_config_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "kube_config_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def refresh(self) -> Optional[pulumi.Input[builtins.bool]]: + """ + If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + return pulumi.get(self, "refresh") + + @refresh.setter + def refresh(self, value: Optional[pulumi.Input[builtins.bool]]): + pulumi.set(self, "refresh", value) + + +@pulumi.type_token("stackit:index/skeKubeconfig:SkeKubeconfig") +class SkeKubeconfig(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + cluster_name: Optional[pulumi.Input[builtins.str]] = None, + expiration: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh: Optional[pulumi.Input[builtins.bool]] = None, + __props__=None): + """ + SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] cluster_name: Name of the SKE cluster. + :param pulumi.Input[builtins.int] expiration: Expiration time of the kubeconfig, in seconds. Defaults to `3600` + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.bool] refresh: If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SkeKubeconfigArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + SKE kubeconfig resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SkeKubeconfigArgs 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(SkeKubeconfigArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + cluster_name: Optional[pulumi.Input[builtins.str]] = None, + expiration: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh: Optional[pulumi.Input[builtins.bool]] = 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__ = SkeKubeconfigArgs.__new__(SkeKubeconfigArgs) + + if cluster_name is None and not opts.urn: + raise TypeError("Missing required property 'cluster_name'") + __props__.__dict__["cluster_name"] = cluster_name + __props__.__dict__["expiration"] = expiration + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["refresh"] = refresh + __props__.__dict__["creation_time"] = None + __props__.__dict__["expires_at"] = None + __props__.__dict__["kube_config"] = None + __props__.__dict__["kube_config_id"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["kubeConfig"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(SkeKubeconfig, __self__).__init__( + 'stackit:index/skeKubeconfig:SkeKubeconfig', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + cluster_name: Optional[pulumi.Input[builtins.str]] = None, + creation_time: Optional[pulumi.Input[builtins.str]] = None, + expiration: Optional[pulumi.Input[builtins.int]] = None, + expires_at: Optional[pulumi.Input[builtins.str]] = None, + kube_config: Optional[pulumi.Input[builtins.str]] = None, + kube_config_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + refresh: Optional[pulumi.Input[builtins.bool]] = None) -> 'SkeKubeconfig': + """ + Get an existing SkeKubeconfig 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[builtins.str] cluster_name: Name of the SKE cluster. + :param pulumi.Input[builtins.str] creation_time: Date-time when the kubeconfig was created + :param pulumi.Input[builtins.int] expiration: Expiration time of the kubeconfig, in seconds. Defaults to `3600` + :param pulumi.Input[builtins.str] expires_at: Timestamp when the kubeconfig expires + :param pulumi.Input[builtins.str] kube_config: Raw short-lived admin kubeconfig. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the cluster is associated. + :param pulumi.Input[builtins.bool] refresh: If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SkeKubeconfigState.__new__(_SkeKubeconfigState) + + __props__.__dict__["cluster_name"] = cluster_name + __props__.__dict__["creation_time"] = creation_time + __props__.__dict__["expiration"] = expiration + __props__.__dict__["expires_at"] = expires_at + __props__.__dict__["kube_config"] = kube_config + __props__.__dict__["kube_config_id"] = kube_config_id + __props__.__dict__["project_id"] = project_id + __props__.__dict__["refresh"] = refresh + return SkeKubeconfig(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="clusterName") + def cluster_name(self) -> pulumi.Output[builtins.str]: + """ + Name of the SKE cluster. + """ + return pulumi.get(self, "cluster_name") + + @property + @pulumi.getter(name="creationTime") + def creation_time(self) -> pulumi.Output[builtins.str]: + """ + Date-time when the kubeconfig was created + """ + return pulumi.get(self, "creation_time") + + @property + @pulumi.getter + def expiration(self) -> pulumi.Output[builtins.int]: + """ + Expiration time of the kubeconfig, in seconds. Defaults to `3600` + """ + return pulumi.get(self, "expiration") + + @property + @pulumi.getter(name="expiresAt") + def expires_at(self) -> pulumi.Output[builtins.str]: + """ + Timestamp when the kubeconfig expires + """ + return pulumi.get(self, "expires_at") + + @property + @pulumi.getter(name="kubeConfig") + def kube_config(self) -> pulumi.Output[builtins.str]: + """ + Raw short-lived admin kubeconfig. + """ + return pulumi.get(self, "kube_config") + + @property + @pulumi.getter(name="kubeConfigId") + def kube_config_id(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "kube_config_id") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the cluster is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def refresh(self) -> pulumi.Output[Optional[builtins.bool]]: + """ + If set to true, the provider will check if the kubeconfig has expired and will generated a new valid one in-place + """ + return pulumi.get(self, "refresh") + diff --git a/sdk/python/pulumi_stackit/sqlserverflex_instance.py b/sdk/python/pulumi_stackit/sqlserverflex_instance.py new file mode 100644 index 0000000..0c2a5f7 --- /dev/null +++ b/sdk/python/pulumi_stackit/sqlserverflex_instance.py @@ -0,0 +1,532 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['SqlserverflexInstanceArgs', 'SqlserverflexInstance'] + +@pulumi.input_type +class SqlserverflexInstanceArgs: + def __init__(__self__, *, + flavor: pulumi.Input['SqlserverflexInstanceFlavorArgs'], + project_id: pulumi.Input[builtins.str], + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + storage: Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + The set of arguments for constructing a SqlserverflexInstance resource. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the SQLServer Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + pulumi.set(__self__, "flavor", flavor) + pulumi.set(__self__, "project_id", project_id) + if acls is not None: + pulumi.set(__self__, "acls", acls) + if backup_schedule is not None: + pulumi.set(__self__, "backup_schedule", backup_schedule) + if name is not None: + pulumi.set(__self__, "name", name) + if options is not None: + pulumi.set(__self__, "options", options) + if region is not None: + pulumi.set(__self__, "region", region) + if storage is not None: + pulumi.set(__self__, "storage", storage) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def flavor(self) -> pulumi.Input['SqlserverflexInstanceFlavorArgs']: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: pulumi.Input['SqlserverflexInstanceFlavorArgs']): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The Access Control List (ACL) for the SQLServer Flex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + """ + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def options(self) -> Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']]: + return pulumi.get(self, "options") + + @options.setter + def options(self, value: Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']]): + pulumi.set(self, "options", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def storage(self) -> Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']]: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']]): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.input_type +class _SqlserverflexInstanceState: + def __init__(__self__, *, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input['SqlserverflexInstanceFlavorArgs']] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']] = None, + version: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering SqlserverflexInstance resources. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the SQLServer Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + :param pulumi.Input[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + if acls is not None: + pulumi.set(__self__, "acls", acls) + if backup_schedule is not None: + pulumi.set(__self__, "backup_schedule", backup_schedule) + if flavor is not None: + pulumi.set(__self__, "flavor", flavor) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if name is not None: + pulumi.set(__self__, "name", name) + if options is not None: + pulumi.set(__self__, "options", options) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if replicas is not None: + pulumi.set(__self__, "replicas", replicas) + if storage is not None: + pulumi.set(__self__, "storage", storage) + if version is not None: + pulumi.set(__self__, "version", version) + + @property + @pulumi.getter + def acls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + The Access Control List (ACL) for the SQLServer Flex instance. + """ + return pulumi.get(self, "acls") + + @acls.setter + def acls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "acls", value) + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + """ + return pulumi.get(self, "backup_schedule") + + @backup_schedule.setter + def backup_schedule(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "backup_schedule", value) + + @property + @pulumi.getter + def flavor(self) -> Optional[pulumi.Input['SqlserverflexInstanceFlavorArgs']]: + return pulumi.get(self, "flavor") + + @flavor.setter + def flavor(self, value: Optional[pulumi.Input['SqlserverflexInstanceFlavorArgs']]): + pulumi.set(self, "flavor", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def options(self) -> Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']]: + return pulumi.get(self, "options") + + @options.setter + def options(self, value: Optional[pulumi.Input['SqlserverflexInstanceOptionsArgs']]): + pulumi.set(self, "options", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def replicas(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "replicas") + + @replicas.setter + def replicas(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "replicas", value) + + @property + @pulumi.getter + def storage(self) -> Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']]: + return pulumi.get(self, "storage") + + @storage.setter + def storage(self, value: Optional[pulumi.Input['SqlserverflexInstanceStorageArgs']]): + pulumi.set(self, "storage", value) + + @property + @pulumi.getter + def version(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "version") + + @version.setter + def version(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "version", value) + + +@pulumi.type_token("stackit:index/sqlserverflexInstance:SqlserverflexInstance") +class SqlserverflexInstance(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['SqlserverflexInstanceFlavorArgs', 'SqlserverflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['SqlserverflexInstanceOptionsArgs', 'SqlserverflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + storage: Optional[pulumi.Input[Union['SqlserverflexInstanceStorageArgs', 'SqlserverflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the SQLServer Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SqlserverflexInstanceArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + SQLServer Flex instance resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SqlserverflexInstanceArgs 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(SqlserverflexInstanceArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['SqlserverflexInstanceFlavorArgs', 'SqlserverflexInstanceFlavorArgsDict']]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['SqlserverflexInstanceOptionsArgs', 'SqlserverflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + storage: Optional[pulumi.Input[Union['SqlserverflexInstanceStorageArgs', 'SqlserverflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.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__ = SqlserverflexInstanceArgs.__new__(SqlserverflexInstanceArgs) + + __props__.__dict__["acls"] = acls + __props__.__dict__["backup_schedule"] = backup_schedule + if flavor is None and not opts.urn: + raise TypeError("Missing required property 'flavor'") + __props__.__dict__["flavor"] = flavor + __props__.__dict__["name"] = name + __props__.__dict__["options"] = options + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["storage"] = storage + __props__.__dict__["version"] = version + __props__.__dict__["instance_id"] = None + __props__.__dict__["replicas"] = None + super(SqlserverflexInstance, __self__).__init__( + 'stackit:index/sqlserverflexInstance:SqlserverflexInstance', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + acls: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + backup_schedule: Optional[pulumi.Input[builtins.str]] = None, + flavor: Optional[pulumi.Input[Union['SqlserverflexInstanceFlavorArgs', 'SqlserverflexInstanceFlavorArgsDict']]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + options: Optional[pulumi.Input[Union['SqlserverflexInstanceOptionsArgs', 'SqlserverflexInstanceOptionsArgsDict']]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + replicas: Optional[pulumi.Input[builtins.int]] = None, + storage: Optional[pulumi.Input[Union['SqlserverflexInstanceStorageArgs', 'SqlserverflexInstanceStorageArgsDict']]] = None, + version: Optional[pulumi.Input[builtins.str]] = None) -> 'SqlserverflexInstance': + """ + Get an existing SqlserverflexInstance 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[Sequence[pulumi.Input[builtins.str]]] acls: The Access Control List (ACL) for the SQLServer Flex instance. + :param pulumi.Input[builtins.str] backup_schedule: The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + :param pulumi.Input[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] name: Instance name. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] region: The resource region. If not defined, the provider region is used. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SqlserverflexInstanceState.__new__(_SqlserverflexInstanceState) + + __props__.__dict__["acls"] = acls + __props__.__dict__["backup_schedule"] = backup_schedule + __props__.__dict__["flavor"] = flavor + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["name"] = name + __props__.__dict__["options"] = options + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["replicas"] = replicas + __props__.__dict__["storage"] = storage + __props__.__dict__["version"] = version + return SqlserverflexInstance(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def acls(self) -> pulumi.Output[Sequence[builtins.str]]: + """ + The Access Control List (ACL) for the SQLServer Flex instance. + """ + return pulumi.get(self, "acls") + + @property + @pulumi.getter(name="backupSchedule") + def backup_schedule(self) -> pulumi.Output[builtins.str]: + """ + The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *") + """ + return pulumi.get(self, "backup_schedule") + + @property + @pulumi.getter + def flavor(self) -> pulumi.Output['outputs.SqlserverflexInstanceFlavor']: + return pulumi.get(self, "flavor") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + Instance name. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter + def options(self) -> pulumi.Output['outputs.SqlserverflexInstanceOptions']: + return pulumi.get(self, "options") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + """ + The resource region. If not defined, the provider region is used. + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter + def replicas(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "replicas") + + @property + @pulumi.getter + def storage(self) -> pulumi.Output['outputs.SqlserverflexInstanceStorage']: + return pulumi.get(self, "storage") + + @property + @pulumi.getter + def version(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "version") + diff --git a/sdk/python/pulumi_stackit/sqlserverflex_user.py b/sdk/python/pulumi_stackit/sqlserverflex_user.py new file mode 100644 index 0000000..b72368e --- /dev/null +++ b/sdk/python/pulumi_stackit/sqlserverflex_user.py @@ -0,0 +1,432 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities + +__all__ = ['SqlserverflexUserArgs', 'SqlserverflexUser'] + +@pulumi.input_type +class SqlserverflexUserArgs: + def __init__(__self__, *, + instance_id: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + username: pulumi.Input[builtins.str], + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None): + """ + The set of arguments for constructing a SqlserverflexUser resource. + :param pulumi.Input[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[builtins.str] username: Username of the SQLServer Flex instance. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + """ + pulumi.set(__self__, "instance_id", instance_id) + pulumi.set(__self__, "project_id", project_id) + pulumi.set(__self__, "username", username) + if region is not None: + pulumi.set(__self__, "region", region) + if roles is not None: + pulumi.set(__self__, "roles", roles) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Input[builtins.str]: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def username(self) -> pulumi.Input[builtins.str]: + """ + Username of the SQLServer Flex instance. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "username", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "roles", value) + + +@pulumi.input_type +class _SqlserverflexUserState: + def __init__(__self__, *, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering SqlserverflexUser resources. + :param pulumi.Input[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] password: Password of the user account. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + :param pulumi.Input[builtins.str] user_id: User ID. + :param pulumi.Input[builtins.str] username: Username of the SQLServer Flex instance. + """ + if host is not None: + pulumi.set(__self__, "host", host) + if instance_id is not None: + pulumi.set(__self__, "instance_id", instance_id) + if password is not None: + pulumi.set(__self__, "password", password) + if port is not None: + pulumi.set(__self__, "port", port) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if region is not None: + pulumi.set(__self__, "region", region) + if roles is not None: + pulumi.set(__self__, "roles", roles) + if user_id is not None: + pulumi.set(__self__, "user_id", user_id) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def host(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "host") + + @host.setter + def host(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @instance_id.setter + def instance_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "instance_id", value) + + @property + @pulumi.getter + def password(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Password of the user account. + """ + return pulumi.get(self, "password") + + @password.setter + def password(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "password", value) + + @property + @pulumi.getter + def port(self) -> Optional[pulumi.Input[builtins.int]]: + return pulumi.get(self, "port") + + @port.setter + def port(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "port", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[builtins.str]]: + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter + def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]: + """ + Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + """ + return pulumi.get(self, "roles") + + @roles.setter + def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]): + pulumi.set(self, "roles", value) + + @property + @pulumi.getter(name="userId") + def user_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @user_id.setter + def user_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "user_id", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[builtins.str]]: + """ + Username of the SQLServer Flex instance. + """ + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "username", value) + + +@pulumi.type_token("stackit:index/sqlserverflexUser:SqlserverflexUser") +class SqlserverflexUser(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.str]] = None, + __props__=None): + """ + SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + :param pulumi.Input[builtins.str] username: Username of the SQLServer Flex instance. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SqlserverflexUserArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param SqlserverflexUserArgs 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(SqlserverflexUserArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + username: Optional[pulumi.Input[builtins.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__ = SqlserverflexUserArgs.__new__(SqlserverflexUserArgs) + + if instance_id is None and not opts.urn: + raise TypeError("Missing required property 'instance_id'") + __props__.__dict__["instance_id"] = instance_id + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["roles"] = roles + if username is None and not opts.urn: + raise TypeError("Missing required property 'username'") + __props__.__dict__["username"] = username + __props__.__dict__["host"] = None + __props__.__dict__["password"] = None + __props__.__dict__["port"] = None + __props__.__dict__["user_id"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["password"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(SqlserverflexUser, __self__).__init__( + 'stackit:index/sqlserverflexUser:SqlserverflexUser', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + host: Optional[pulumi.Input[builtins.str]] = None, + instance_id: Optional[pulumi.Input[builtins.str]] = None, + password: Optional[pulumi.Input[builtins.str]] = None, + port: Optional[pulumi.Input[builtins.int]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + region: Optional[pulumi.Input[builtins.str]] = None, + roles: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None, + user_id: Optional[pulumi.Input[builtins.str]] = None, + username: Optional[pulumi.Input[builtins.str]] = None) -> 'SqlserverflexUser': + """ + Get an existing SqlserverflexUser 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[builtins.str] instance_id: ID of the SQLServer Flex instance. + :param pulumi.Input[builtins.str] password: Password of the user account. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the instance is associated. + :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] roles: Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + :param pulumi.Input[builtins.str] user_id: User ID. + :param pulumi.Input[builtins.str] username: Username of the SQLServer Flex instance. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SqlserverflexUserState.__new__(_SqlserverflexUserState) + + __props__.__dict__["host"] = host + __props__.__dict__["instance_id"] = instance_id + __props__.__dict__["password"] = password + __props__.__dict__["port"] = port + __props__.__dict__["project_id"] = project_id + __props__.__dict__["region"] = region + __props__.__dict__["roles"] = roles + __props__.__dict__["user_id"] = user_id + __props__.__dict__["username"] = username + return SqlserverflexUser(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def host(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "host") + + @property + @pulumi.getter(name="instanceId") + def instance_id(self) -> pulumi.Output[builtins.str]: + """ + ID of the SQLServer Flex instance. + """ + return pulumi.get(self, "instance_id") + + @property + @pulumi.getter + def password(self) -> pulumi.Output[builtins.str]: + """ + Password of the user account. + """ + return pulumi.get(self, "password") + + @property + @pulumi.getter + def port(self) -> pulumi.Output[builtins.int]: + return pulumi.get(self, "port") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the instance is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def region(self) -> pulumi.Output[builtins.str]: + return pulumi.get(self, "region") + + @property + @pulumi.getter + def roles(self) -> pulumi.Output[Optional[Sequence[builtins.str]]]: + """ + Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##` + """ + return pulumi.get(self, "roles") + + @property + @pulumi.getter(name="userId") + def user_id(self) -> pulumi.Output[builtins.str]: + """ + User ID. + """ + return pulumi.get(self, "user_id") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[builtins.str]: + """ + Username of the SQLServer Flex instance. + """ + return pulumi.get(self, "username") + diff --git a/sdk/python/pulumi_stackit/volume.py b/sdk/python/pulumi_stackit/volume.py new file mode 100644 index 0000000..9c3336b --- /dev/null +++ b/sdk/python/pulumi_stackit/volume.py @@ -0,0 +1,545 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import copy +import warnings +import sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['VolumeArgs', 'Volume'] + +@pulumi.input_type +class VolumeArgs: + def __init__(__self__, *, + availability_zone: pulumi.Input[builtins.str], + project_id: pulumi.Input[builtins.str], + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None, + source: Optional[pulumi.Input['VolumeSourceArgs']] = None): + """ + The set of arguments for constructing a Volume resource. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the volume. + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume is associated. + :param pulumi.Input[builtins.str] description: The description of the volume. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the volume. + :param pulumi.Input[builtins.str] performance_class: The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + :param pulumi.Input[builtins.int] size: The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + :param pulumi.Input['VolumeSourceArgs'] source: The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + """ + pulumi.set(__self__, "availability_zone", availability_zone) + pulumi.set(__self__, "project_id", project_id) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if performance_class is not None: + pulumi.set(__self__, "performance_class", performance_class) + if size is not None: + pulumi.set(__self__, "size", size) + if source is not None: + pulumi.set(__self__, "source", source) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> pulumi.Input[builtins.str]: + """ + The availability zone of the volume. + """ + return pulumi.get(self, "availability_zone") + + @availability_zone.setter + def availability_zone(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "availability_zone", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[builtins.str]: + """ + STACKIT project ID to which the volume is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[builtins.str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the volume. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the volume. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + """ + return pulumi.get(self, "performance_class") + + @performance_class.setter + def performance_class(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "performance_class", value) + + @property + @pulumi.getter + def size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + """ + return pulumi.get(self, "size") + + @size.setter + def size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "size", value) + + @property + @pulumi.getter + def source(self) -> Optional[pulumi.Input['VolumeSourceArgs']]: + """ + The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input['VolumeSourceArgs']]): + pulumi.set(self, "source", value) + + +@pulumi.input_type +class _VolumeState: + def __init__(__self__, *, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None, + source: Optional[pulumi.Input['VolumeSourceArgs']] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None): + """ + Input properties used for looking up and filtering Volume resources. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the volume. + :param pulumi.Input[builtins.str] description: The description of the volume. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the volume. + :param pulumi.Input[builtins.str] performance_class: The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume is associated. + :param pulumi.Input[builtins.str] server_id: The server ID of the server to which the volume is attached to. + :param pulumi.Input[builtins.int] size: The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + :param pulumi.Input['VolumeSourceArgs'] source: The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + if availability_zone is not None: + pulumi.set(__self__, "availability_zone", availability_zone) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if performance_class is not None: + pulumi.set(__self__, "performance_class", performance_class) + if project_id is not None: + pulumi.set(__self__, "project_id", project_id) + if server_id is not None: + pulumi.set(__self__, "server_id", server_id) + if size is not None: + pulumi.set(__self__, "size", size) + if source is not None: + pulumi.set(__self__, "source", source) + if volume_id is not None: + pulumi.set(__self__, "volume_id", volume_id) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The availability zone of the volume. + """ + return pulumi.get(self, "availability_zone") + + @availability_zone.setter + def availability_zone(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "availability_zone", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The description of the volume. + """ + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The name of the volume. + """ + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + """ + return pulumi.get(self, "performance_class") + + @performance_class.setter + def performance_class(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "performance_class", value) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + STACKIT project ID to which the volume is associated. + """ + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The server ID of the server to which the volume is attached to. + """ + return pulumi.get(self, "server_id") + + @server_id.setter + def server_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "server_id", value) + + @property + @pulumi.getter + def size(self) -> Optional[pulumi.Input[builtins.int]]: + """ + The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + """ + return pulumi.get(self, "size") + + @size.setter + def size(self, value: Optional[pulumi.Input[builtins.int]]): + pulumi.set(self, "size", value) + + @property + @pulumi.getter + def source(self) -> Optional[pulumi.Input['VolumeSourceArgs']]: + """ + The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + """ + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input['VolumeSourceArgs']]): + pulumi.set(self, "source", value) + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> Optional[pulumi.Input[builtins.str]]: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + + @volume_id.setter + def volume_id(self, value: Optional[pulumi.Input[builtins.str]]): + pulumi.set(self, "volume_id", value) + + +@pulumi.type_token("stackit:index/volume:Volume") +class Volume(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None, + source: Optional[pulumi.Input[Union['VolumeSourceArgs', 'VolumeSourceArgsDict']]] = None, + __props__=None): + """ + Volume resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[builtins.str] availability_zone: The availability zone of the volume. + :param pulumi.Input[builtins.str] description: The description of the volume. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the volume. + :param pulumi.Input[builtins.str] performance_class: The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume is associated. + :param pulumi.Input[builtins.int] size: The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + :param pulumi.Input[Union['VolumeSourceArgs', 'VolumeSourceArgsDict']] source: The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: VolumeArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Volume resource schema. Must have a `region` specified in the provider configuration. + + ## Example Usage + + :param str resource_name: The name of the resource. + :param VolumeArgs 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(VolumeArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None, + source: Optional[pulumi.Input[Union['VolumeSourceArgs', 'VolumeSourceArgsDict']]] = 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__ = VolumeArgs.__new__(VolumeArgs) + + if availability_zone is None and not opts.urn: + raise TypeError("Missing required property 'availability_zone'") + __props__.__dict__["availability_zone"] = availability_zone + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["performance_class"] = performance_class + if project_id is None and not opts.urn: + raise TypeError("Missing required property 'project_id'") + __props__.__dict__["project_id"] = project_id + __props__.__dict__["size"] = size + __props__.__dict__["source"] = source + __props__.__dict__["server_id"] = None + __props__.__dict__["volume_id"] = None + super(Volume, __self__).__init__( + 'stackit:index/volume:Volume', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + availability_zone: Optional[pulumi.Input[builtins.str]] = None, + description: Optional[pulumi.Input[builtins.str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]] = None, + name: Optional[pulumi.Input[builtins.str]] = None, + performance_class: Optional[pulumi.Input[builtins.str]] = None, + project_id: Optional[pulumi.Input[builtins.str]] = None, + server_id: Optional[pulumi.Input[builtins.str]] = None, + size: Optional[pulumi.Input[builtins.int]] = None, + source: Optional[pulumi.Input[Union['VolumeSourceArgs', 'VolumeSourceArgsDict']]] = None, + volume_id: Optional[pulumi.Input[builtins.str]] = None) -> 'Volume': + """ + Get an existing Volume 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[builtins.str] availability_zone: The availability zone of the volume. + :param pulumi.Input[builtins.str] description: The description of the volume. + :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] labels: Labels are key-value string pairs which can be attached to a resource container + :param pulumi.Input[builtins.str] name: The name of the volume. + :param pulumi.Input[builtins.str] performance_class: The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + :param pulumi.Input[builtins.str] project_id: STACKIT project ID to which the volume is associated. + :param pulumi.Input[builtins.str] server_id: The server ID of the server to which the volume is attached to. + :param pulumi.Input[builtins.int] size: The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + :param pulumi.Input[Union['VolumeSourceArgs', 'VolumeSourceArgsDict']] source: The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + :param pulumi.Input[builtins.str] volume_id: The volume ID. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _VolumeState.__new__(_VolumeState) + + __props__.__dict__["availability_zone"] = availability_zone + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["performance_class"] = performance_class + __props__.__dict__["project_id"] = project_id + __props__.__dict__["server_id"] = server_id + __props__.__dict__["size"] = size + __props__.__dict__["source"] = source + __props__.__dict__["volume_id"] = volume_id + return Volume(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="availabilityZone") + def availability_zone(self) -> pulumi.Output[builtins.str]: + """ + The availability zone of the volume. + """ + return pulumi.get(self, "availability_zone") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[builtins.str]: + """ + The description of the volume. + """ + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, builtins.str]]]: + """ + Labels are key-value string pairs which can be attached to a resource container + """ + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[builtins.str]: + """ + The name of the volume. + """ + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="performanceClass") + def performance_class(self) -> pulumi.Output[builtins.str]: + """ + The performance class of the volume. Possible values are documented in [Service plans BlockStorage](https://docs.stackit.cloud/stackit/en/service-plans-blockstorage-75137974.html#ServiceplansBlockStorage-CurrentlyavailableServicePlans%28performanceclasses%29) + """ + return pulumi.get(self, "performance_class") + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Output[builtins.str]: + """ + STACKIT project ID to which the volume is associated. + """ + return pulumi.get(self, "project_id") + + @property + @pulumi.getter(name="serverId") + def server_id(self) -> pulumi.Output[builtins.str]: + """ + The server ID of the server to which the volume is attached to. + """ + return pulumi.get(self, "server_id") + + @property + @pulumi.getter + def size(self) -> pulumi.Output[builtins.int]: + """ + The size of the volume in GB. It can only be updated to a larger value than the current size. Either `size` or `source` must be provided + """ + return pulumi.get(self, "size") + + @property + @pulumi.getter + def source(self) -> pulumi.Output[Optional['outputs.VolumeSource']]: + """ + The source of the volume. It can be either a volume, an image, a snapshot or a backup. Either `size` or `source` must be provided + """ + return pulumi.get(self, "source") + + @property + @pulumi.getter(name="volumeId") + def volume_id(self) -> pulumi.Output[builtins.str]: + """ + The volume ID. + """ + return pulumi.get(self, "volume_id") + diff --git a/sdk/python/setup.py b/sdk/python/setup.py new file mode 100644 index 0000000..1599caa --- /dev/null +++ b/sdk/python/setup.py @@ -0,0 +1,46 @@ +# coding=utf-8 +# *** WARNING: this file was generated by pulumi-language-python. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import builtins +import errno +from setuptools import setup, find_packages +from setuptools.command.install import install +from subprocess import check_call + + +VERSION = "0.0.0" +def readme(): + try: + with open('README.md', encoding='utf-8') as f: + return f.read() + except FileNotFoundError: + return "stackit Pulumi Package - Development Version" + + +setup(name='pulumi_stackit', + python_requires='>=3.9', + version=VERSION, + description="A Pulumi package for creating and managing stackit resources.", + long_description=readme(), + long_description_content_type='text/markdown', + keywords='pulumi stackit category/utility', + url='https://www.pulumi.com', + project_urls={ + 'Repository': 'https://github.com/stackitcloud/pulumi-stackit' + }, + license='Apache-2.0', + packages=find_packages(), + package_data={ + 'pulumi_stackit': [ + 'py.typed', + 'pulumi-plugin.json', + ] + }, + install_requires=[ + 'parver>=0.2.1', + 'pulumi>=3.0.0,<4.0.0', + 'semver>=2.8.1', + 'typing-extensions>=4.11,<5; python_version < "3.11"' + ], + zip_safe=False)